Java的反射机制

写在Spring Ioc之前
类装载器就是寻找类的字节码文件并构造出类在JVM内部表示的对象组件，主要工作由ClassLoader及其子类负责，ClassLoader是一个重要的java运行时系统组件，他负责在运行时查找和装入Class字节码文件

public class ReflectCar {
    public static Car initCarByDefaultConst() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        ClassLoader loader=Thread.currentThread().getContextClassLoader();
        Class clazz=loader.loadClass("com.beijinghuayi.ioc.Car");
        //获取类默认实例化对象
        Constructor constructor=clazz.getDeclaredConstructor((Class[])null);
        Car car= (Car) constructor.newInstance();

        Method setBrand=clazz.getMethod("setBrand",String.class);
        setBrand.invoke(car,"奔驰");
        Method setColor=clazz.getMethod("setColor",String.class);
        setColor.invoke(car,"红色");
        Method setMaxspeed=clazz.getMethod("setMaxspeed",String.class);
        setMaxspeed.invoke(car,"200码");
        return car;
    }
    public static Car initCarByParams() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        ClassLoader loader=Thread.currentThread().getContextClassLoader();
        Class clazz=loader.loadClass("com.beijinghuayi.ioc.Car");
        Constructor constructor=clazz.getDeclaredConstructor(new Class[]{String.class,String.class,String.class});
        Car car= (Car) constructor.newInstance(new Object[]{"红色","宝马","180"});
        return car;
    }
}

工作机制：

• 1.装载：查找和导入Class文件
• 2.链接：执行校验，准备和解析步骤
• 3.初始化：对类的静态变量、静态代码块执行初始化操作

Tip:JVM在运行时会产生3个classLoader

• 根装载器（C++实现、不是classloader的子类）装载jre核心类库
• ExtClassLoader（扩展类装载器）装载jre扩展目录ext中的jar类
• AppClassLoader（系统类装载器）装载classpath中的内容

ClassLoader重要方法

• Class loadClass(String name);从文件中装在类
• Class defineClass(String name,byte[]b,int off,int len)
• Class findSystemClass(String name)
• Class findLoadedClass(String name)
• ClassLoader getParent()

Class反射对象描述类语义结构，可以从Class对象中获得构造函数，成员变量，方法等元素的反射对象，并以编程的方法通过这些反射对象对目标类对象进行操作。这些反射对象类在java.reflect包中定义，下面是最主要的三个反射类

• 1.Constructor类对象的反射类（通过getConstructor方法可以获得类的所有构造函数反射对象数组）NewInstance。
• 2.Method类方法的反射类invoke() getReturnType(),getParameterTypes();
• 3.Field 获取类的成员变量反射类（ 获取成员变量反射数组）
  Tip访问private，protect成员变量或方法时需添加Field.setAccessible(true)，Method.setAccessible(true)方法取消java语言检查，否则将会抛出IllegalAccessException异常.

 ClassLoader loader=Thread.currentThread().getContextClassLoader();
        System.out.println("classLoader:"+loader);
        System.out.println("parent classLoader:"+loader.getParent());
        System.out.println("grandParent classLoader:"+loader.getParent().getParent());

引出Spring Ioc

在Spring中，通过IOC可以将实现类、参数信息等配置在对应的配置文件中，那么当需要更改实现类或参数信息时，只需要修改配置文件即可，我们还可以对某对象所需要的其他对象进行注入，这种注入都是在配置文件中实现。

Spring Bean的简单实现

public class BeanFactory {
    private Map<String,Object> beanmap=new HashMap<>();
    public void init(String xml) throws DocumentException, ClassNotFoundException, IntrospectionException, IllegalAccessException, InstantiationException, InvocationTargetException {
        //1.创建读取配置文件的reader对象
        SAXReader reader=new SAXReader();
        //2.获取当前线程的类加载器
        ClassLoader loader=Thread.currentThread().getContextClassLoader();
        //3.从class目录下获取指定的xml文件
        InputStream ins=loader.getResourceAsStream(xml);
        Document doc=reader.read(ins);
        Element root=doc.getRootElement();
        Element foo;

        //4.遍历xml文件中的Bean实例
        for(Iterator i=root.elementIterator("bean");i.hasNext();){
            foo= (Element) i.next();
            //5.针对每一个bean实例，获取bean的属性id和class
            Attribute id=foo.attribute("id");
            Attribute cls=foo.attribute("class");

            //6.利用Java反射机制，通过class的名称获取Class对象
            Class bean=Class.forName(cls.getText());
            //7.获取丢应class信息
            java.beans.BeanInfo info =java.beans.Introspector.getBeanInfo(bean);
            //8.获取其属性描述
            java.beans.PropertyDescriptor pd[]=info.getPropertyDescriptors();
            //9.创建一个对象，并在接下来的代码中为对象的属性赋值
            Object obj=bean.newInstance();
            //10.遍历该bean的property属性
            for(Iterator ite=foo.elementIterator("property");ite.hasNext();){
                Element foo2= (Element) ite.next();
                //11.获取该property的name属性
                Attribute name=foo2.attribute("name");
                String value=null;
                //12.获取该property的子元素的值
                for (Iterator ite1 = foo2.elementIterator("value"); ite1.hasNext();)
                {
                    Element node = (Element) ite1.next();
                    value = node.getText();
                    break;
                }

                //13.利用Java的反射机制调用对象的某个set方法，并将值设置进去
                for (int k = 0; k < pd.length; k++) {
                    if (pd[k].getName().equalsIgnoreCase(name.getText()))
                    {
                        Method mSet = null;
                        mSet = pd[k].getWriteMethod();
                        mSet.invoke(obj, value);
                    }
                }
            }
            //14.将对象放入beanMap中，其中key为id值，value为对象
            beanmap.put(id.getText(), obj);
        }
    }
    /**
     * 通过bean的id获取bean的对象.
     *
     * @param beanName
     *            bean的id
     * @return 返回对应对象
     */
    public Object getBean(String beanName) {
        Object obj = beanmap.get(beanName);
        return obj;
    }
}

config.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans>
    <bean id="javaBean" class="JavaBean">
        <property name="username">
            <value>mic_swift</value>
        </property>
        <property name="password">
            <value>010101010110</value>
        </property>
    </bean>
</beans>

Spring资源访问工具类

JDK所提供的访问资源类并不能很好的满足各种底层资源的访问需求，因此，Spring设计了一个Resource接口，它为应用提供了更强大的访问底层资源的能力：
主要方法：

• boolean exists()
• boolean isOpen()
• URL getURL();
• File getFile();
• inputStream getInputStream();

具体实现类

• ByteArrayResource
• ClassPathResource
• FileSystemResource
• InputStreamResource
• ServletContextResource
• UrlResource

为了访问不同类型的资源，必须使用相应的Resource实现类，Spring提供了一个强大的加载资源的机制，能够自动识别不同的资源类型。
资源类型地址前缀

• classpath classpath:com/example/config.xml
• File file:/com/example/config.xml
• Http http://www.baidu.com
• Ftp ftp://www.baidu.com
• 无前缀 com/example/config.xml

BeanFactory和ApplicationContext

BeanFactory时Spring框架的最核心接口，它提供高级的Ioc配置机制，AppliactionContext建立在BeanFactory基础上，提供了更多面向应用的功能，它提供了国际化支持和框架事件体系，更易于创建实际应用一般成BeanFactory为Ioc容器，而称ApplicationContext为应用上下文

BeanFactory是一个类工厂，可以常见并管理各种类的对象，Spring称这些创建和管理的java对象为bean，在Spring中，java对象的范围更加宽泛，接下来我们对BeanFactory的类体系结构以及装载初始化顺序进行说明：

类体系结构

• XmlBeanFactory
• ListableBeanFactory
• HierarhicalBeanFactory
• ConfigurableBeanFactory
• AutowireCapableBeanFactory
• SingletonBeanFactory
• BeanDefinitionRegistry

初始化顺序

• 创建配置文件
• 装载配置文件
• 启动Ioc容器
• 获取Bean实例

ApplicationContext由BeanFactory派生而来，提供了更多面向实际的功能。在BeanFactory中，很多功能需要以编程的方式实现，而在ApplicationContext中则可以通过配置的方式实现，接下来介绍一下ApplicationContext的实现类以及类体系结构：

具体实现类

• ClassPathXmlApplicationContext
• FileSystemXmlApplicationContext
• ConfigurableApplicationContext
  类继承体系(扩展接口)
• ApplicationEventPublisher
• MessageSource
• ResourcePatternResolver
• LifeCycle(用于处理异步)

Spring容器中的Bean拥有明确的生命周期，由多个特定的生命阶段组成，每个生命阶段都允许外界对Bean进行控制，在Spring中，我们从Bean的作用范围和实例化Bean时所经历的一系列阶段来描述Bean的生命周期

• BeanFactory中的Bean的生命周期
• ApplicationContext中的Bean的生命周期

Spring容器启动基本条件

• Spring框架类包
• Bean配置信息
• Bean类满足

Bean的元数据信息

• Bean的实现类
• Bean的属性信息
• Bean的依赖关系
• Bean的行为配置
• Bean的创建方式

使用静态工厂的方式除了指定必须的class属性，还要指定factory-method属性来指定实例化Bean的方法，而且使用静态工厂方法也允许指定方法参数，SpringIoc容器将调用此属性的方法来获取Bean。

使用实例工厂方法不能指定clas属性，此时必须使用factory-bean来指定工厂Bean，factory-method属性指定实例化Bean的方法，而且使用实例工厂方法允许指定方法参数，方式和使用构造器方式一样

<bean id="beanInstanceFactory" class="com.beijinghuayi.spring.Instance"/>
    <bean id="helloWorldInstance" factory-bean="beanInstanceFactory" factory-method="newInstance">
        <constructor-arg index="0" value="Hello Instance Factory!"></constructor-arg>
</bean>

Spring多个配置文件的整合

<beans>
    <import resource="common/Spring-Common.xml"/>
    <import resource="common/Spring-Connect.xml"/>
    <import resource="common/Spring-Moudel.xml"/>
</beans>

我的文章列表