精华内容
下载资源
问答
  • java反射在spring中的应用

    千次阅读 2015-01-18 22:01:31
    java反射在spring中的应用

       1.为什么要用反射?

        根据对象可以得到该类的所有信息,可以做直接操作对象不能做的事,它不是在编译时执行,而是在运行时执行,也就是执行.class时执行,所以它可以做在编译时不能做的事,像hibernate的属性映射就是通过反射来赋值的,spring的bean的创建就是根据配置的class来反射构建的


      2.反射怎么用

         我就不像网上说一大堆理论知识了,直接写个spring注入的例子

        

    <span style="font-size:18px;">public class ReflectDemo
    {
        public static void main(String[] args)
        {
    
            try
            {
                String classPath = "com.chenjun.Compute";// 由spring中bean 的class属性值传进来
    
                Class class1 = Class.forName(classPath); // 这是获得class对象最常用的方式,还有.class,getClass()两种方式
    
                Object object = class1.newInstance();
    
                String attrName = "a";// 代表spring中待注入的属性
                String attrValue = "hello";// 代表spring中待注入的属性值
                Method method = class1.getMethod("set" + attrName.toUpperCase(), String.class);
                method.invoke(object, attrValue);// 调用setter方法为bean注入属性值
    
                System.out.println(object.toString());
    
            }
            catch (SecurityException e)
            {
                e.printStackTrace();
            }
    
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    }
    
    class Compute
    {
    
        private String a;
    
        public String getA()
        {
            return a;
        }
    
        public void setA(String a)
        {
            this.a = a;
        }
    
        @Override
        public String toString()
        {
            return a;
        }
    
    }</span>

    输出:hello,说明注入成功,这个class对应的bean也就创建成功



    展开全文
  • IOC:即“控制反转”,不是什么技术,而是一种思想。...在Spring的配置文件,经常看到如下配置:那么通过这样配置,Spring是怎么帮我们实例化对象,并且放到容器去了了?对,就是通过反射!!!下面是Spring通过...

    IOC:即“控制反转”,不是什么技术,而是一种思想。使用IOC意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制。

    本篇文章主要讲解一下IOC底层实现的原理(反射),Bean容器的实现,就不对IOC的概念进行详述了。

    在Spring的配置文件中,经常看到如下配置:

    那么通过这样配置,Spring是怎么帮我们实例化对象,并且放到容器中去了了?对,就是通过反射!!!

    下面是Spring通过配置进行实例化对象,并放到容器中的伪代码:

    //解析元素的id属性得到该字符串值为“courseDao”

    String idStr = "courseDao";

    //解析元素的class属性得到该字符串值为“com.qcjy.learning.Dao.impl.CourseDaoImpl”

    String classStr = "com.qcjy.learning.Dao.impl.CourseDaoImpl";

    //利用反射知识,通过classStr获取Class类对象

    Class> cls = Class.forName(classStr);

    //实例化对象

    Object obj = cls.newInstance();

    //container表示Spring容器

    container.put(idStr, obj);

    通过解析xml文件,获取到id属性和class属性里面的内容,利用反射原理获取到配置里面类的实例对象,存入到Spring的bean容器中。

    当一个类里面需要应用另一类的对象时,Spring的配置如下所示:

    我们继续用伪代码的形式来模拟实现一下Spring底层处理原理:

    //解析元素的name属性得到该字符串值为“courseDao”

    String nameStr = "courseDao";

    //解析元素的ref属性得到该字符串值为“courseDao”

    String refStr = "courseDao";

    //生成将要调用setter方法名

    String setterName = "set" + nameStr.substring(0, 1).toUpperCase()

    + nameStr.substring(1);

    //获取spring容器中名为refStr的Bean,该Bean将会作为传入参数

    Object paramBean = container.get(refStr);

    //获取setter方法的Method类,此处的cls是刚才反射代码得到的Class对象

    Method setter = cls.getMethod(setterName, paramBean.getClass());

    //调用invoke()方法,此处的obj是刚才反射代码得到的Object对象

    setter.invoke(obj, paramBean);

    通过上面对Spring底层原理的分析,可以发现,其实并不难,用到的都是反射机制,通过反射实例化对象,存入到Spring的bean容器中。

    只要在代码或配置文件中看到类的完整路径(包.类),其底层原理基本上使用的就是Java的反射机制。

    展开全文
  • IOC 控制翻转,它是一种设计思想,而并非实际技术,最核心思想就是预先将设计对象实例创建控制权交给程序(IOC容器) ...beans xmlns="http://www.springframework.org/schema/beans" xm...

    IOC

    • 控制翻转,它是一种设计思想,而并非实际的技术,最核心的思想就是预先将设计的对象实例创建的控制权交给程序(IOC容器)
    • IOC容器的本质是一个K-V结构的map

    配置文件

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    
        <!-- 创建方式1:空参构造创建 -->
        <bean id="a" class="com.liulin.demo6.A"/>
    
        <!--
            创建方式2:静态工厂创建
            调用A的createBObj方法来创建名为b的对象放入容器
        -->
        <bean id="b" class="com.liulin.demo6.A" factory-method="createBObj"/>
    
        <!--
                创建方式3:实例工厂创建
                调用实例a的createCObj方法来创建名为c的对象放入容器
         -->
        <bean id="c" factory-bean="a" factory-method="createCObj"/>
    
    
    </beans>
    

    代码

    public class A {
    
        public A() {
            System.out.println("A 无参构造器被调用了.");
        }
    
        public static B createBObj() {
            System.out.println("A 的静态方法 createBObj 被调用了.");
            return new B();
        }
    
          public C createCObj() {
            System.out.println("A 的实例方法 createCObj 被调用了.");
            return new C();
        }
    
    }
    

    BeanConfig类

    public class BeanConfig {
    
        private String id;
        private String clazz;
        private String factoryMethod;
        private String factoryBean;
    
        public String getId() {
            return id;
        }
    
        public void setId(String id) {
            this.id = id;
        }
    
        public String getClazz() {
            return clazz;
        }
    
        public void setClazz(String clazz) {
            this.clazz = clazz;
        }
    
        public String getFactoryMethod() {
            return factoryMethod;
        }
    
        public void setFactoryMethod(String factoryMethod) {
            this.factoryMethod = factoryMethod;
        }
    
        public String getFactoryBean() {
            return factoryBean;
        }
    
        public void setFactoryBean(String factoryBean) {
            this.factoryBean = factoryBean;
        }
    }
    

    Init类

    public class Init {
    
        public static void main(String[] args) throws Exception {
    
            //  模拟解析xml   拿到 beanConfigs
            List<BeanConfig> beanConfigs = parseXmltoBeanConfig();
            //循环
            for (BeanConfig tmpconfig : beanConfigs) {
                if (null != tmpconfig.getClazz()) {
                    //拿到clazz
                    Class clazz = Class.forName(tmpconfig.getClazz());
                    if (null != tmpconfig.getFactoryMethod())
                    {
                        //基于Class对象获取method对象
                        Method method = clazz.getDeclaredMethod(tmpconfig.getFactoryMethod());
                        IOCContainer.putBean(tmpconfig.getId(), method.invoke(null));
    
                    } else {    //构造器创建bean实例
                        IOCContainer.putBean(tmpconfig.getId(), clazz.newInstance());
                    }
                } else if(null != tmpconfig.getFactoryBean()) {
                    //从容器中拿到实体bean
                    Object obj = IOCContainer.getBean( tmpconfig.getFactoryBean());
                    Method method = obj.getClass().getDeclaredMethod(tmpconfig.getFactoryMethod());
                    IOCContainer.putBean(tmpconfig.getId(),  method.invoke(obj));
                }else{
                    System.out.println("不知道在搞什么鬼.2个核心的配置都没有!");
                }
            }
        }
        
        /**
         * 模拟一个解析XML过程
         *
         * @return
         */
        private static List<BeanConfig> parseXmltoBeanConfig() {
    
            List<BeanConfig> beanConfigs = new ArrayList<BeanConfig>();
            BeanConfig beanConfig1 = new BeanConfig();
            beanConfig1.setClazz("com.liulin.reflect.demo6.A");
            beanConfig1.setId("a");
            beanConfigs.add(beanConfig1);
    
            BeanConfig beanConfig2 = new BeanConfig();
            beanConfig2.setClazz("com.liulin.reflect.demo6.A");
            beanConfig2.setId("b");
            beanConfig2.setFactoryMethod("createBObj");
            beanConfigs.add(beanConfig2);
    
            BeanConfig beanConfig3 = new BeanConfig();
            beanConfig3.setId("c");
            beanConfig3.setFactoryBean("a");
            beanConfig3.setFactoryMethod("createCObj");
            beanConfigs.add(beanConfig3);
    
            return beanConfigs;
        }
    }
    
    

    IOCContainer类

    public class IOCContainer {
    
        private static HashMap container = new HashMap();
    
        public static void putBean(String id,Object object){
            container.put(id,object);
        }
    
        public static Object getBean(String id){
            return container.get(id);
        }
    
    }
    
    展开全文
  • Java反射机制在Spring IOC中的应用

    万次阅读 多人点赞 2016-10-10 09:48:01
    IOC:即“控制反转”,不是什么技术,而是一种思想。...在Spring的配置文件,经常看到如下配置: 那么通过这样配置,Spring是怎么帮我们实例化对象,并且放到容器去了了?对,就是通过反射!!! 下面是Spring通过

    IOC:即“控制反转”,不是什么技术,而是一种思想。使用IOC意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制。

    本篇文章主要讲解一下IOC底层实现的原理(反射),Bean容器的实现,就不对IOC的概念进行详述了。

    在Spring的配置文件中,经常看到如下配置:

    <bean id="courseDao" class="com.qcjy.learning.Dao.impl.CourseDaoImpl"></bean>

    那么通过这样配置,Spring是怎么帮我们实例化对象,并且放到容器中去了了?对,就是通过反射!!!

    下面是Spring通过配置进行实例化对象,并放到容器中的伪代码:

    //解析<bean .../>元素的id属性得到该字符串值为“courseDao”
    String idStr = "courseDao";
    //解析<bean .../>元素的class属性得到该字符串值为“com.qcjy.learning.Dao.impl.CourseDaoImpl”
    String classStr = "com.qcjy.learning.Dao.impl.CourseDaoImpl";
    //利用反射知识,通过classStr获取Class类对象
    Class<?> cls = Class.forName(classStr);
    //实例化对象
    Object obj = cls.newInstance();
    //container表示Spring容器
    container.put(idStr, obj);
    通过解析xml文件,获取到id属性和class属性里面的内容,利用反射原理获取到配置里面类的实例对象,存入到Spring的bean容器中。


    当一个类里面需要应用另一类的对象时,Spring的配置如下所示:

    <bean id="courseService" class="com.qcjy.learning.service.impl.CourseServiceImpl">
         <!-- 控制调用setCourseDao()方法,将容器中的courseDao bean作为传入参数 -->
         <property name="courseDao" ref="courseDao"></property>
    </bean>
    我们继续用伪代码的形式来模拟实现一下Spring底层处理原理:

    //解析<property .../>元素的name属性得到该字符串值为“courseDao”
    String nameStr = "courseDao";
    //解析<property .../>元素的ref属性得到该字符串值为“courseDao”
    String refStr = "courseDao";
    //生成将要调用setter方法名
    String setterName = "set" + nameStr.substring(0, 1).toUpperCase()
    		+ nameStr.substring(1);
    //获取spring容器中名为refStr的Bean,该Bean将会作为传入参数
    Object paramBean = container.get(refStr);
    //获取setter方法的Method类,此处的cls是刚才反射代码得到的Class对象
    Method setter = cls.getMethod(setterName, paramBean.getClass());
    //调用invoke()方法,此处的obj是刚才反射代码得到的Object对象
    setter.invoke(obj, paramBean);

    通过上面对Spring底层原理的分析,可以发现,其实并不难,用到的都是反射机制,通过反射实例化对象,存入到Spring的bean容器中。

    只要在代码或配置文件中看到类的完整路径(包.类),其底层原理基本上使用的就是Java的反射机制。




    展开全文
  • IOC:即“控制反转”,不是什么技术,而是一种思想。使用IOC意味着将你设计好对象交给容器控制,而不是传统在你对象...在Spring的配置文件,经常看到如下配置: [html] view plain copy print? bean
  • spring 的反射应用

    2020-02-05 16:51:15
    spring中反射的应用 https://blog.csdn.net/mlc1218559742/article/details/52774805 spring解析xml文件拿出bean元素,接着通过反射(newinstance)来创建实例 (此处是根据元素名字用反射找到对应的类) 为...
  • 前言Spring框架对于Java后端程序员来说再熟悉不过了,以前只知道它用的反射实现,但了解之后才知道有很多巧妙设计里面。如果不看Spring的源码,你将会失去一次和大师学习机会:它代码规范,设计思想很值得...
  • 反射观点Java的反射就是行使加载到jvm中的.class文件来举行操作的。.class文件中包罗java类的所有信息,当你不知道某个类详细信息时,可以使用反射获取class,然后举行种种操作。运行状态中,对于随便一个类,通过...
  • 本篇文章介绍下自定义注解在Spring中的具体使用,底层其实就是利用扫描注解,并利用反射和动态代理去实现,下面会有三个例子,希望对您有所帮助。 自定义通用注解 使用过SpringBoot的同学都知道,它是一个...
  • 思路是,通过java的反射机制得到类字段和字段类型,从而可以创建一个map集合存储表名(由类名决定特殊结构字符串),表字段(由类变量确定),表字段类型(由变量类型确定),DAO通过将map传递给mybatis,mybatis ...
  • aop.spring,springmvc,mybatis,反射
  • 运行状态时,把类中的各个成分映射成一个一个Java对象; 对于任何一个类,都可以知道它的属性和方法,这种动态获取信息以及调用类对象方法的功能称为反射机制 Spring框架 核心为IOC和AOP,IOC基于注入和Java反射...
  • 我们平时项目开发过程,基本上很少会直接使用到反射机制,但这不能说明反射机制没有用,实际上有很多设计、开发都与反射机制有关,例如模块化开发,通过反射去调用对应字节码;动态代理设计模式也采用了...
  • spring中通过IOC反射机制获取bean默认就是单例模式。 配置如下: 运行结果是: 单例:true 非单例:false
  • 项目会自动有一个名为Applicationjava文件,相当于一个接口程序,通过运行该文件和添加反射注释,加载其他类文件,该文件一运行就不会停止4.由于要编写代码级别必须要比Application小,或者会扫描不到,这里...
  • 从而可以创建一个map集合存储表名(由类名决定特殊结构字符串),表字段(由类变量确定),表字段类型(由变量类型确定),DAO通过将map传递给mybatis,mybatis 中调用存储过程生成表。 1,数据库添加一...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 583
精华内容 233
关键字:

反射在spring中的应用

spring 订阅