Java反射——框架设计的灵魂

100000860378

发布于 2018-09-13 15:21:59

5130

发布于 2018-09-13 15:21:59

文章被收录于专栏：spring源码深度学习spring源码深度学习

java反射概念：

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

获取Class类的实例对象的三种方式

在面向对象的世界里，万事万物皆对象。（java语言中，静态的成员、普通数据类型除外)

类是不是对象呢?类是(哪个类的对象呢?)谁的对象呢?

类是对象，类是java.lang.Class类的实例对象

//第一种、已知User的实例化对象，通过user.getClass()获得Class对象       
User user = new User();
Class c1 = user.getClass();
//第二种、知道User类名通过 .class获得Class对象，需要导包       
Class c2 = User.class;
Class c3 = null;
try {
/第三种、知道User的完全名（包名.类名） 通过Class.forName("java_reflex.User")获得Class对象 
    c3 = Class.forName("java_reflex.User");
    } catch (ClassNotFoundException e) {
    // TODO Auto-generated catch block
        e.printStackTrace();
    }
System.out.println(c1==c2);//true
System.out.println(c1==c3);//true
System.out.println(c3==c2);//true
//都为true,这就说明一个类只可能是Class类的一个实例对象，只是方式不同。

静态加载和动态加载

静态加载（需要重新编译）：

//获取User的实例对象
User user = new User();

动态加载（不需要重新编译）：

//newInstance() 获取User的实例化对象
try {
        Class c3 = Class.forName("java_reflex.User");
        c3.newInstance();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

举个栗子：

我们手机里的app要更新升级的时候，即使你不更新，也可以正常使用，但是不能使用更新的功能。我们的杀毒软件，需要下载一个功能插件时，不需要卸载掉重新安装完整版，只需要下载插件即可。这里面就用到了反射的知识哦。不需要重新编译，扩展所需功能即可。

代码示意：

假如有个Office，具有word、excel功能。

静态方式：

public interface OfficeAble {
    public void print();
}

public class Word implements OfficeAble {

    @Override
    public void print() {
        System.out.println("word-----start");
    }
}

public class Excel implements OfficeAble {

    @Override
    public void print() {
        System.out.println("excel-------statrt");
    }
}

Office.java

public class Office {
    public static OfficeAble fun(String name) {
        OfficeAble officeAble = null;
        if("word".equals(name)) {
            officeAble = new Word();
        }
        if("excel".equals(name)) {
            officeAble = new Excel();
        }
        return officeAble;
    }

    public static void main(String[] args) {
        Office.fun("word").print();
        Office.fun("excel").print();
    }

}

静态的方式必须要保证Word、Excel这两个类必须存在。假如现在Office需要ppt的功能，就要新建一个Ppt类实现OfficeAble并且改写Office业务代码，并且还要重新编译运行。

动态方式：

public class OfficeBetter {
    public static OfficeAble fun(String className) {
        OfficeAble officeAble=null;
        try {
            //动态加载类
            Class clazz = Class.forName(className);
            officeAble =  (OfficeAble) clazz.newInstance();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return officeAble;
    }

    public static void main(String[] args) {
        OfficeBetter clazz = new OfficeBetter();
        OfficeAble officeAble = clazz.fun("demo.Ppt");
        officeAble.print();
    }

}

动态方式，要ppt功能时只需要实现OfficeAble 即可，不需要改写Office的业务代码，不需要重新编译。

注：在编辑器里不好演示是否重新编译，可通过 javac命令在cmd中测试。

通过反射对构造器、方法、属性的操作：

User.java

package java_reflex;

public class User {
    private Integer id;
    private String username;
    private String password;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public User(Integer id, String username, String password) {
        super();
        this.id = id;
        this.username = username;
        this.password = password;
    }
    public User() {
        super();
        // TODO Auto-generated constructor stub
    }
    public User(String username, String password) {
        super();
        this.username = username;
        this.password = password;
    }
    @Override
    public String toString() {
        return "User [username=" + username + ", password=" + password + "]";
    }
    
    private void hello() {
        System.out.println("hello world");
    }
}

test.java

package java_reflex;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class test {
    public static void main(String[] args) {
        try {
            Class clazzUser = Class.forName("java_reflex.User");
            Constructor[] constructors = clazzUser.getDeclaredConstructors();
            System.out.println("----------获取所有公有的构造器----------");
            for(Constructor c:constructors) {
                System.out.println(c);
            }
            
        Constructor  con = clazzUser.getConstructor(String.class,String.class);
        //con.setAccessible(true);
        Object obj  = con.newInstance("stefan","password");
        System.out.println("----------实例化----------");
        System.out.println(obj.toString());
        Method[] methods = clazzUser.getMethods();
        System.out.println("----------获取所有公有方法----------");
        for(Method m :methods) {
            System.out.println(m);
        }
        
        System.out.println("----------获取所有私有方法----------");
        Method[] declaredmethods = clazzUser.getDeclaredMethods();
        for(Method m :declaredmethods) {
            System.out.println(m);
        }
        
        System.out.println("----------setUsername的调用----------");
        Method setUsername = clazzUser.getMethod("setUsername", String.class);
        Object obj1 = clazzUser.newInstance();
        setUsername.invoke(obj1, "tom");
        System.out.println(obj1.toString());
        
        System.out.println("----------私有方法hello的调用----------");
        Method hello = clazzUser.getDeclaredMethod("hello", null);
        hello.setAccessible(true);
        hello.invoke(obj1, null);
        
        System.out.println("----------获得私有私有属性----------");
        Field[] fields = clazzUser.getDeclaredFields();
        for(Field f:fields) {
            System.out.println(f);
        }
        
        System.out.println("----------username的set和get----------");
        Field username = clazzUser.getDeclaredField("username");
        username.setAccessible(true);
        Object obj2 = clazzUser.newInstance();
        username.set(obj2, "xufanyun");
        System.out.println(username.get(obj2));
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

运行结果：
----------获取所有公有的构造器----------
public java_reflex.User(java.lang.String,java.lang.String)
public java_reflex.User()
public java_reflex.User(java.lang.Integer,java.lang.String,java.lang.String)
----------实例化----------
User [username=stefan, password=password]
----------获取所有公有方法----------
public java.lang.String java_reflex.User.toString()
public java.lang.Integer java_reflex.User.getId()
public void java_reflex.User.setId(java.lang.Integer)
public void java_reflex.User.setUsername(java.lang.String)
public java.lang.String java_reflex.User.getPassword()
public void java_reflex.User.setPassword(java.lang.String)
public java.lang.String java_reflex.User.getUsername()
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
----------获取所有私有方法----------
public java.lang.String java_reflex.User.toString()
public java.lang.Integer java_reflex.User.getId()
public void java_reflex.User.setId(java.lang.Integer)
public void java_reflex.User.setUsername(java.lang.String)
private void java_reflex.User.hello()
public java.lang.String java_reflex.User.getPassword()
public void java_reflex.User.setPassword(java.lang.String)
public java.lang.String java_reflex.User.getUsername()
----------setUsername的调用----------
User [username=tom, password=null]
----------私有方法hello的调用----------
hello world
----------获得私有私有属性----------
private java.lang.Integer java_reflex.User.id
private java.lang.String java_reflex.User.username
private java.lang.String java_reflex.User.password
----------username的set和get----------
xufanyun

getMethods()和getDeclaredMethods()的区别：

1、getMethods(),该方法是获取本类以及父类或者父接口中所有的公共方法(public修饰符修饰的)

image

2、getDeclaredMethods(),该方法是获取本类中的所有方法，包括私有的(private、protected、默认以及public)的方法。

image

同理获取构造器和属性有无Declared的区别。

通过反射对集合泛型的深入理解

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

public class test3 {

    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("aa");
        list.add(100);
        
        List<String> list1 = new ArrayList<>();
        
        list1.add("bb");
        //list1.add(100);会报错
        Class c1 = list.getClass();
        Class c2 = list1.getClass();
        System.out.println(c1==c2);
        /**
         * c1==c2 true  说明编译之后集合的泛型是去泛型化的，
         * java中集合的泛型，是防止错误输入的，只在编译阶段有效
         * 跳过编译就无效了
         */
        try {
            Object o1 = c2.newInstance();
            Method add = c2.getMethod("add", Object.class);
            add.invoke(o1,"bb");
            add.invoke(o1,200);
            add.invoke(list1, 30);
            System.out.println(o1);
            System.out.println(list1);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

}

运行结果：
true
[bb, 200]
[bb, 30]

本文参与腾讯云自媒体分享计划，分享自作者个人站点/博客。

原始发表：2018.05.21 ，如有侵权请联系 cloudcommunity@tencent.com 删除

其他

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体分享计划，欢迎热爱写作的你一起参与！

其他

登录后参与评论

0 条评论

热度