反射基础及其实际应用

反射

1.获取class对象的三种方法

1. Class c1=Date.class// 字节码

2. Date d=new Date();

   Class c2=d.getClass() //通过对象的getClass()方法

3. Class.forName()//通过Class类的静态方法

   Class.forName()的作用 ，用于返回字节码，返回的方式有两种

   1. 若内存已经加载了这个字节码，直接返回
   2. 若不存在，则通过类加载器加载，放在虚拟机中，返回。

2.字节码在内存中只存在一份

String st1="aa";
        Class cls1=String.class;
        Class cls2=st1.getClass();
        try {
            Class cls3=Class.forName("java.lang.String");
            System.out.println(cls1==cls2);
            System.out.println(cls1==cls3);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
// true,true

​

3.反射就是把一个java类中的每一个成员映射成对应的java类

4.具体的方法

1. 构造方法

   //通过构造方法来创建对象
          //new String(new StringBuffer("abc"))
   
          //选择哪一个构造方法,得到方法的时候，需要类型
          Constructor<String> constructor = String.class.getConstructor(StringBuffer.class);
   
          //传入参数来new对象,调用的时候也需要类型
          String s = constructor.newInstance(new StringBuffer("abc"));
          System.out.println(s);
   //abc

5.实际应用

1.通过反射修改私有变量的值

public class TestBean {
    private int x;
    private int y;
    private String str1;
    private String str2;
    private String str3;

    public TestBean(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public String getStr1() {
        return str1;
    }

    public void setStr1(String str1) {
        this.str1 = str1;
    }

    public String getStr2() {
        return str2;
    }

    public void setStr2(String str2) {
        this.str2 = str2;
    }

    public String getStr3() {
        return str3;
    }

    public void setStr3(String str3) {
        this.str3 = str3;
    }
}

public class MainTest {
    public static void main(String[] args) throws IllegalAccessException {
        TestBean testBean=new TestBean(3,4);
        testBean.setStr1("abcccc");
        testBean.setStr2("abaaa");
        testBean.setStr3("aqqqq");
        System.out.println(testBean.getStr1());
        System.out.println(testBean.getStr2());
        System.out.println(testBean.getStr3());
        System.out.println("######");
        //将reflectPoint对象中字段为a的修改为p
        Class<? extends TestBean> aClass = testBean.getClass();
        Field[] declaredFields = aClass.getDeclaredFields();
        for (Field f:declaredFields){
            if (f.getType()==String.class){
                //允许访问
                f.setAccessible(true);
                String o = (String)f.get(testBean);
                String replace = o.replace('a', 'p');
                f.set(testBean,replace);
                f.setAccessible(false);
            }      
        }
        System.out.println(testBean.getStr1());
        System.out.println(testBean.getStr2());
        System.out.println(testBean.getStr3());
    }
}
//输出
/*
    abcccc
    abaaa
    aqqqq
    ######
    pbcccc
    pbppp
    pqqqq
*/

2.通过反射批量设置数据

解析xml数据，设置到对象，开始是硬解析（注释掉的部分），匹配节点名称，这样太麻烦了，用反射后，根据bean中的属性和node节点的名称来匹配，批量设置值。

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
import org.junit.Test;

import java.io.File;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

/**
 * Created by easzz on 2017/11/14 16:33
 */
public class Test4Xml {
    public static void main(String[] args) throws Exception {
        SAXReader saxReader = new SAXReader();
        OutSalesHeader outSalesHeader = new OutSalesHeader();

        Recipient recipient = new Recipient();
        Document doc = saxReader.read(new File("d:/n.xml"));

        List<Node> list1 = doc.selectNodes("/request/*");
        for (Node node : list1) {
            nodeText2BeanProperties(outSalesHeader,node);
            /*if ("customerCode".equals(node.getName())) {
                outSalesHeader.setCustomerCode(node.getText());
            }
            if ("warehouseCode".equals(node.getName())) {
                outSalesHeader.setWarehouseCode(node.getText());
            }
            if ("orderCode".equals(node.getName())) {
                outSalesHeader.setOrderCode(node.getText());
            }
            if ("orderType".equals(node.getName())) {
                outSalesHeader.setOrderType(node.getText());
            }
            if ("orderStatus".equals(node.getName())) {
                outSalesHeader.setOrderStatus(node.getText());
            }
            if ("logisticsProviderCode".equals(node.getName())) {
                outSalesHeader.setLogisticsProviderCode(node.getText());
            }
            if ("shippingOrderNo".equals(node.getName())) {
                outSalesHeader.setShippingOrderNo(node.getText());
            }
            if ("weight".equals(node.getName())) {
                outSalesHeader.setWeight(node.getText());
            }
            if ("volume".equals(node.getName())) {
                outSalesHeader.setVolume(node.getText());
            }
            if ("extOrderType".equals(node.getName())) {
                outSalesHeader.setExtOrderType(node.getText());
            }
            if ("note".equals(node.getName())) {
                outSalesHeader.setNote(node.getText());
            }*/

        }
        //System.out.println(outSalesHeader);

        List<Node> recipientNode = doc.selectNodes("/request/recipient/*");

        for (Node node : recipientNode) {

            nodeText2BeanProperties(recipient,node);
            /*System.out.println(recipient);
            if ("name".equals(node.getName())) {
                recipient.setName(node.getText());
            }
            if ("mobileNumber".equals(node.getName())) {
                recipient.setMobileNumber(node.getText());
            }
            if ("province".equals(node.getName())) {
                recipient.setProvince(node.getText());
            }
            if ("city".equals(node.getName())) {
                recipient.setCity(node.getText());
            }
            if ("district".equals(node.getName())) {
                recipient.setDistrict(node.getText());
            }
            if ("shippingAddress".equals(node.getName())) {
                recipient.setShippingAddress(node.getText());
            }*/
            outSalesHeader.setRecipient(recipient);
        }
        //System.out.println(outSalesHeader);

        List<Element> productsElemets = doc.selectNodes("/request/products/*");
        List<Product> productList = new ArrayList<>();
        for (Element productsElemet : productsElemets) {
            Product product = new Product();
            List<Node> elements = productsElemet.elements();
            for (Node node : elements) {
                nodeText2BeanProperties(product,node);
                /*if ("skuCode".equals(node.getName())) {
                    product.setSkuCode(node.getText());
                }
                if ("normalQuantity".equals(node.getName())) {
                    product.setNormalQuantity(node.getText());
                }
                if ("defectiveQuantity".equals(node.getName())) {
                    product.setDefectiveQuantity(node.getText());
                }
                if ("averageWeight".equals(node.getName())) {
                    product.setAverageWeight(node.getText());
                }
                if ("lineNo".equals(node.getName())) {
                    product.setLineNo(node.getText());
                }*/
                //获取此node节点下的 batchs
                if ("batchs".equals(node.getName())) {
                    //product.setLineNo(node.getText());
                    List<Element> batchElements = node.selectNodes("./batch");
                    List<Batch> batchList = new ArrayList<>();
                    for (Element e : batchElements) {
                        List<Node> batchNodes = e.elements();
                        Batch batch = new Batch();
                        for (Node batchNode : batchNodes) {
                            nodeText2BeanProperties(batch,batchNode);
                            /*if ("fixStatusCode".equals(batchNode.getName())) {
                                batch.setFixStatusCode(batchNode.getText());
                            }
                            if ("packCode".equals(batchNode.getName())) {
                                batch.setPackCode(batchNode.getText());
                            }
                            if ("quantity".equals(batchNode.getName())) {
                                batch.setQuantity(batchNode.getText());
                            }*/
                        }
                        batchList.add(batch);

                    }
                    product.setBatchList(batchList);
                }
            }
            productList.add(product);
        }
        outSalesHeader.setProductList(productList);
        //System.out.println(outSalesHeader);
        List<Element> boxesElement = doc.selectNodes("/request/boxes/*");
        List<Box> boxList = new ArrayList<>();
        for (Element element : boxesElement) {
            List<Node> boxesNode = element.elements();
            Box box = new Box();
            for (Node node : boxesNode) {
                nodeText2BeanProperties(box,node);
                /*if ("boxCode".equals(node.getName())) {
                    box.setBoxCode(node.getText());
                }
                if ("boxName".equals(node.getName())) {
                    box.setBoxName(node.getText());
                }*/
            }
            boxList.add(box);
        }
        outSalesHeader.setBoxList(boxList);
        //System.out.println(outSalesHeader);
        List<Element> packagesElement = doc.selectNodes("/request/packages/*");
        List<Package> packageList = new ArrayList<>();
        for (Element element : packagesElement) {
            Package pack = new Package();
            List<Node> elements = element.elements();
            for (Node node : elements) {
                nodeText2BeanProperties(pack,node);
                /*if ("packCode".equals(node.getName())) {
                    pack.setPackCode(node.getText());
                }
                if ("packLogisticsProviderCode".equals(node.getName())) {
                    pack.setPackLogisticsProviderCode(node.getText());
                }
                if ("packShippingOrderNo".equals(node.getName())) {
                    pack.setPackShippingOrderNo(node.getText());
                }
                if ("packWeight".equals(node.getName())) {
                    pack.setPackWeight(node.getText());
                }
                if ("packVolume".equals(node.getName())) {
                    pack.setPackVolume(node.getText());
                }
                if ("packLength".equals(node.getName())) {
                    pack.setPackLength(node.getText());
                }
                if ("packWidth".equals(node.getName())) {
                    pack.setPackWidth(node.getText());
                }
                if ("packHeight".equals(node.getName())) {
                    pack.setPackHeight(node.getText());
                }*/
                if ("packProducts".equals(node.getName())) {
                    List<Element> packProductElements = node.selectNodes("./packProduct");
                    List<PackProduct> packProductList = new ArrayList<>();
                    for (Element element1 : packProductElements) {
                        List<Node> nodes = element1.elements();
                        PackProduct packProduct = new PackProduct();
                        for (Node node1 : nodes) {
                            nodeText2BeanProperties(packProduct,node1);
                            /*if ("packSkuCode".equals(node1.getName())) {
                                packProduct.setPackSkuCode(node1.getText());
                            }
                            if ("packFixStatusCode".equals(node1.getName())) {
                                packProduct.setPackFixStatusCode(node1.getText());
                            }
                            if ("packQuantity".equals(node1.getName())) {
                                packProduct.setPackQuantity(node1.getText());
                            }
                            if ("packCode".equals(node1.getName())) {
                                packProduct.setPackCode(node1.getText());
                            }*/
                        }
                        packProductList.add(packProduct);
                    }
                    pack.setPackProductList(packProductList);
                }
            }
            packageList.add(pack);
        }
        outSalesHeader.setPackageList(packageList);
        //System.out.println(outSalesHeader);


        List<SnCodeItem> snCodeItemList = new ArrayList<>();
        List<Element> snCodeElement = doc.selectNodes("/request/snCodeItems/*");
        for (Element element : snCodeElement) {
            List<Node> elements = element.elements();
            SnCodeItem snCodeItem = new SnCodeItem();
            for (Node node : elements) {
                nodeText2BeanProperties(snCodeItem,node);
                /*if ("skuCode".equals(node.getName())) {
                    snCodeItem.setSkuCode(node.getText());
                }*/
                if ("snCodeList".equals(node.getName())) {
                    List<Node> snCodeListElement = node.selectNodes("./snCode");
                    List<String> snCodes = new ArrayList<>();
                    for (Node node1 : snCodeListElement) {
                        if ("snCode".equals(node1.getName())) {
                            snCodes.add(node1.getText());
                        }
                    }
                    snCodeItem.setSnCode(snCodes);
                }

            }
            snCodeItemList.add(snCodeItem);

        }
        outSalesHeader.setSnCodeItemList(snCodeItemList);
        System.out.println(outSalesHeader);
    }

    /**
     * 将node 中的节点数据转为bean中的属性
     * 只转换bean中属性类型为String的数据
     *
     * @param o
     * @param node
     * @throws InvocationTargetException
     * @throws IllegalAccessException
     */
    public static void nodeText2BeanProperties(Object o, Node node) throws InvocationTargetException, IllegalAccessException {
        String name = node.getName();
        name = name.replaceFirst(name.substring(0, 1), name.substring(0, 1).toUpperCase());
        Method[] declaredMethods = o.getClass().getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            String methodName = declaredMethod.getName();

            if (methodName.equals("set" + name)) {
                if (declaredMethod.getParameterTypes().length == 1 && declaredMethod.getParameterTypes()[0] == String.class) {
                    declaredMethod.invoke(o, node.getText());
                }
            }
        }
    }

}

5.bean转map

javabean 转成map

    public Map bean2Map(Object o) throws IntrospectionException, InvocationTargetException, IllegalAccessException {
        Map<String, Object> m = new HashMap<>();
        //获取beaninfo，通过propertyDescriptor来获得相关 get set 方法
        BeanInfo beanInfo = Introspector.getBeanInfo(o.getClass());
        //获得所有的属性描述  
        PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
        for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
            String key = propertyDescriptor.getName();
          //需要去除 class 属性
            if (!"class".equals(key)) {
                Method readMethod = propertyDescriptor.getReadMethod();
                Object invoke = readMethod.invoke(o);
                m.put(key, invoke);
            }

        }
        return m;
    }