java反射总结

反射

为什么使用反射

类的执行过程

• 编译——>加载——>连接（验证，准备，解析）——>初始化

类的加载步骤

• JVM将.class文件读入内存方法区
• JVM为.class创建唯一的Class对象

package shangpin;
//商品工厂，根据厂家需求，生产不同商品
public class Factory {
    //生产商品:使用父类作为商品返回值类型
    //str代表用户想获取的相拼类型Foods  TVs-累的完整限定名（包括包名）
    public Goods getGoods(String className){
        //获取类型对应的Class对象实例
        //在通过Class的newInstance()生成响应类的实例
        Goods goods =null;
        try {
            //反射应用
            goods = (Goods) Class.forName(className).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return goods;
    }
}

package shangpin;
//测试商品生产，输出商品价格功能
public class Test {
    public static void main(String[] args) {
        Factory factory=new Factory();
        Goods goods=factory.getGoods("shangpin.Foods");
        goods.printPrince();

        goods=factory.getGoods("shangpin.TVs");
        goods.printPrince();
    }
}

package shangpin;

public class TVs extends Goods{
    public void printPrince(){
        System.out.println("打印输出电视价格");
    }
}
package shangpin;

public abstract class Goods {
    //打印输出商品价格
    public abstract void printPrince();
}
package shangpin;

public class Foods extends Goods{
    public void printPrince(){
        System.out.println("打印输出食品价格");
    }
}

什么是反射

反射：Reflection

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

Person p=new Student()

person是编译时对象

student是运行时对象

反射让我们在运行时看清一个类的运行情况并使用

反射让java被视为动态或准动态语言

反射允许程序在运行时加载，探查，使用一个在编译期可能未知的类

反射API

• Class类：反射的核心类，可以获取类的属性，方法等信息，生成类的实例位于java.lang包
• Field类：表示类的成员变量，可用来获取和设置类的属性值位于java.lang.reflect包
• Method类：表示类的方法，可用来获取类中的方法信息或执行方法
• Constructor类：表示类的构造方法

Class

通过Class类的对象可以

• 获取类的属性，方法
• 生成类的实例
• 调用实例的方法，属性

反射通过操作Class类的对象

• 实现对类的操作
• 实现对对象的操作

使用反射的步骤

• 获取想要操作的类的Class对象

  • 通过Class类的静态方法：

    Class class=Class.forName(className)

    Goods goods=(Goods)Class.forName(className).newInstance();

  • 调用对象实例的getClass()方法

  • 调用某个类的class属性

• 调用Class类中的方法

  • 获取类的属性
    • getFields()——所有可访问的公共字段
    • getDeclaredFields()——所有字段
    • getField(String name)返回一个特点的公共字段
  • 获取类的方法
    • getMethods()—所有公共方法，包括从超类和超接口继承的声明
    • getDeclaredMethods()—所有方法，包括公共，保护，默认访问，私有方法，但不包括继承的方法
    • getMethods(String name,Class[] parameterTypes)–返回一个方法对象

• 使用反射API来操作这些信息

package zhujie;
//获取person类对应的Class对象
public class Person {
    public static void main(String[] args) {
        //方式1.通过class。forname
        try {
            Class c=Class.forName("zhujie.Person");
            System.out.println(c);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        //2.通过对象实例的getclass方法
        Person p=new Person();
        Class c2=p.getClass();
        System.out.println(c2);

        //3.通过类的class属性
        Class c3=Person.class;
        System.out.println(c3);
    }
}

方式一更常用，对于编译期并不知道对象类型，在运行期对未知类型进行操作时更常用

基于反射获取类信息

需求：给予反射，通过调用Class的相应方法，实现Person类信息的获取（属性，方法）

package zhujie;

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

public class TestRef {
    public static void main(String[] args) throws Exception{
        //获取class对象
        Class c = Class.forName("zhujie.Person1");
        //调用class方法
        //获取类的相关属性
        Field[] fields1 = c.getFields();//范文所有公共字段
        Field[] fields2=c.getDeclaredFields();//所有字段
        Field address=c.getField("address");//返回一个特定的公共field字段
        System.out.println("获取公共的特定字段"+address);

        //获取相关方法
        Method[] methods1 = c.getMethods();//所有公共方法，包括继承的
        Method[] methods2 = c.getDeclaredMethods();//包括公共，保护，默认访问，私有方法，但不包括继承的方法


        //调用相应反射API完成需求
        System.out.println("所有可访问的公共字段");
        for(Field f:fields1){
            System.out.println(f.getName());
        }
        System.out.println("所有可访问的字段");
        for(Field f:fields2){
            System.out.println(f.getName());
        }
        System.out.println("所有公共方法");
        for(Method m:methods1){
            System.out.println(m.getName());
        }
        System.out.println("包括公共，保护，默认访问，私有方法，但不包括继承的方法");
        for(Method m:methods2){
            System.out.println(m.getName());

        }
    }
}

基于反射生成类的实例

获取构造方法

• getConstructor(Class[] parameterTypes)—返回一个构造方法对象

括号里面不带参数得到无参构造，带参数得到有参构造

通过Constructor-newInstance(Object[] initargs)可以生成类的实例

通过Method-invoke(Object obj,Object[] args)可在具有指定参数的方法对象上调用此方法对象表示的基础方法

需求：基于反射，通过调用Class的相应方法，通过构造方法实现Person类对象的创建

package zhujie;

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

public class TestRef {
    public static void main(String[] args) throws Exception{
        //获取class对象
        Class c = Class.forName("zhujie.Person1");
        //调用class方法
        //获取类的相关属性
        Field[] fields1 = c.getFields();//范文所有公共字段
        Field[] fields2=c.getDeclaredFields();//所有字段
        Field address=c.getField("address");//返回一个特定的公共field字段
        System.out.println("获取公共的特定字段"+address);

        //获取相关方法
        Method[] methods1 = c.getMethods();//所有公共方法，包括继承的
        Method[] methods2 = c.getDeclaredMethods();//包括公共，保护，默认访问，私有方法，但不包括继承的方法


        //调用相应反射API完成需求
        System.out.println("所有可访问的公共字段");
        for(Field f:fields1){
            System.out.println(f.getName());
        }
        System.out.println("所有可访问的字段");
        for(Field f:fields2){
            System.out.println(f.getName());
        }
        System.out.println("所有公共方法");
        for(Method m:methods1){
            System.out.println(m.getName());
        }
        System.out.println("包括公共，保护，默认访问，私有方法，但不包括继承的方法");
        for(Method m:methods2){
            System.out.println(m.getName());

        }
        System.out.println("利用对象调用方法");
        //获取构造方法对象
        Constructor constructor = c.getConstructor();//获取无餐构造方法对象
        //根据构造方法对象完成对象实例化
        Object obj = constructor.newInstance();
        //通过实例，调用相应方法
        //1.获取相应的方法对象method对象,第一个参数方法名，第二个参数，方法中的参数类型(无参写null)
        //如果两个参数new Class[]{int.class,String.class}
        Method method=c.getMethod("showInfo",null);
        //2.调用相应方法
        method.invoke(obj,null);

        System.out.println("利用对象调用方法");
        //获取构造方法对象
        Constructor constructor2 = c.getConstructor(new Class[]{int.class,String.class,String.class});//获取无餐构造方法对象
        Object obj2=constructor2.newInstance(new Object[]{18,"张三","北京超燕"});
        Method method2=c.getMethod("showInfo",null);
        method2.invoke(obj2,null);

    }
}

反射实现解耦

需求：

​ 现有一电商系统,需要按促销时间点， 采用不同促销策略,， 其中包括儿童节促销策略、国庆促销策略、双11促销策略等
​ 原实现思路为：根据节日选择不同的促销策略(创建相应对象，调用方法)现要求：使用反射根据节日名称字符串创建节日对象，调用相应促销方法

普通思路

package dianshang;
//儿童节
public class ChildrenDayPS {
    public ChildrenDayPS() {
    }
    public double promoteSales(String productId){
        System.out.println("编号"+productId+"的商品打六折");
        return 0.6;
    }
}

package dianshang;

public class NationalDayPS {
    public NationalDayPS() {
    }
    public double promoteSales(String productID){
        System.out.println("编号"+productID+"的商品打七折");
        return 0.7;
    }
}


package dianshang;

public class ProductSale {
    public void productSale(String productId) {
        //其他操作
        //......
        //不同节日，调用不同促销
        ChildrenDayPS childrenDayPS = new ChildrenDayPS();
        double discount = childrenDayPS.promoteSales(productId);
        System.out.println("节日折扣为:"+discount);
        /*NationalDayPS nationalDayPS=new NationalDayPS();
        double discount=nationalDayPS.promotateSales(productId);
        System.out.println("节日折扣为:"+discount);*/
        //其他操作
        //。。。。。。
    }

    public static void main(String[] args) {
        ProductSale ps=new ProductSale();
        ps.productSale("p001");
    }
}

反射思路修改

实现步骤

• 获取促销类的构造方法
• 通过促销类的构造方法，生成促销类的实例
• 调用该实例的促销方法

用到的反射的类

• java.lang.Class
• java.lang.reflect.Constructor
• java.lang.reflect.Method

package dianshang;
//儿童节
public class ChildrenDayPS {
    public ChildrenDayPS() {
    }
    public double promoteSales(String productId){
        System.out.println("编号"+productId+"的商品打六折");
        return 0.6;
    }
}

package dianshang;

public class NationalDayPS {
    public NationalDayPS() {
    }
    public double promoteSales(String productID){
        System.out.println("编号"+productID+"的商品打七折");
        return 0.7;
    }
}

package dianshang;

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

public class ProductSale {
    //className:不同商品的锉削方案
    public void productSaleByRef(String productId,String className) {
        try {
            Class c=Class.forName(className);
            //根据clss获取构造方法对象
            Constructor constructor=c.getConstructor();
            //根据构造方法去完成对象实例化
            Object obj = constructor.newInstance();
            Method method=c.getMethod("promoteSales",String.class);
            double discount = (double) method.invoke(obj, productId);
            System.out.println("节日折扣为："+discount);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {
        ProductSale productSale=new ProductSale();
        productSale.productSaleByRef("p001","dianshang.ChildrenDayPS");
        productSale.productSaleByRef("p001","dianshang.NationalDayPS");

    }
}

反射总结

优点

• 运行期类型的判断，动态加载类
• 提高了程序的灵活性，扩展性，降低耦合性
• 提高自适应能力，无序提前硬编码目标类

缺点：

• 性能问题
• 安全限制
• 内部暴露

反射机制是目前众多java框架实现的基础

• JDBC
• Hibernate
• Spring AOP,IoC
• 分布式微服

实现项目安装插件功能

基于反射，架构师搭建项目框架，自行封装框架，使得项目更加组件化和通用化