spring mvc的注入属性原理，怎样才能知道哪个属性注入到哪里

最新推荐文章于 2022-01-14 15:22:27 发布
最新推荐文章于 2022-01-14 15:22:27 发布
阅读量1.2k 收藏
点赞数
分类专栏： java

定义一些抽象的方法：

[java]
package com.huxin.springinject.dao; 
 
public interface Person { 
    public void save(); 
    public void useAxe(); 
} 

package com.huxin.springinject.dao;

public interface Person {
    public void save();
    public void useAxe();
}

[java]
package com.huxin.springinject.dao; 
 
public interface Axe { 
   public void  chop(); 
    
} 

package com.huxin.springinject.dao;

public interface Axe {
   public void  chop();
  
}
实现的一些方法：

[java]
package com.huxin.springinject.dao.impl; 
 
import com.huxin.springinject.dao.Axe; 
import com.huxin.springinject.dao.Person; 
 
public class Chinese implements Person { 
    private Axe axe;     
    public Axe getAxe() { 
        return axe; 
    } 
 
    public void setAxe(Axe axe) { 
        this.axe = axe; 
    } 
 
    public void save() { 
        System.out.println("保存人的方法"); 
    }    
    public void useAxe(){ 
        axe.chop(); 
    } 
} 

package com.huxin.springinject.dao.impl;

import com.huxin.springinject.dao.Axe;
import com.huxin.springinject.dao.Person;

public class Chinese implements Person {
 private Axe axe; 
 public Axe getAxe() {
  return axe;
 }

 public void setAxe(Axe axe) {
  this.axe = axe;
 }

 public void save() {
        System.out.println("保存人的方法");
 } 
 public void useAxe(){
  axe.chop();
 }
}

 

[java]
package com.huxin.springinject.dao.impl; 
 
import com.huxin.springinject.dao.Axe; 
 
public class StoneAxe implements Axe { 
 
    @Override 
    public void chop() { 
       System.out.println("铁斧头砍柴真慢"); 
 
    } 
 
} 

package com.huxin.springinject.dao.impl;

import com.huxin.springinject.dao.Axe;

public class StoneAxe implements Axe {

 @Override
 public void chop() {
    System.out.println("铁斧头砍柴真慢");

 }

}
这里是关键spring框架模拟的实现的一些原理！！！

[java]
package junit.test; 
import java.beans.Introspector; 
import java.beans.PropertyDescriptor; 
import java.lang.reflect.Method; 
import java.net.URL; 
import java.util.ArrayList; 
import java.util.HashMap; 
import java.util.List; 
import java.util.Map; 
 
import org.apache.commons.beanutils.ConvertUtils; 
import org.dom4j.Document; 
import org.dom4j.Element; 
import org.dom4j.XPath; 
import org.dom4j.io.SAXReader; 
public class ApplicationContext { 
     List<BeanInformation> beansInformation = new ArrayList<BeanInformation>(); 
     Map<String,Object> singleton = new HashMap<String,Object>(); 
      
      
     public ApplicationContext(){}; 
     public ApplicationContext(String filename){ 
         readXml(filename); 
         initBean(); 
         this.injectObject(); 
     } 
     public void readXml(String filename){ 
         SAXReader saxReader = new SAXReader(); 
         Document document = null; 
         try{ 
             //使用反射机制,通过文件名加载文件路径  
             URL xmlPath = this.getClass().getClassLoader().getResource(filename); 
              
             //通过文件路径获得这个文件的document对象  
             document = saxReader.read(xmlPath); 
              
             Map<String,String> nsMap = new HashMap<String,String>(); 
             nsMap.put("ns","http://www.springframework.org/schema/beans");//加入命名空间 
              
             XPath xsub = document.createXPath("//ns:beans/ns:bean");//创建beans/bean查询路径 
             xsub.setNamespaceURIs(nsMap);//设置命名空间  
         
             //获得所有路径下的节点  
             List<Element> beans = xsub.selectNodes(document);//获取文档下所有bean节点  
             for(Element element : beans){ 
                 System.out.println(element.attributeValue("id")); 
                 System.out.println(element.attributeValue("class")); 
                  
                 BeanInformation beanInformation = new BeanInformation(); 
                 beanInformation.setId(element.attributeValue("id")); 
                 beanInformation.setName(element.attributeValue("class")); 
                  
                 XPath xref = element.createXPath("ns:property");//创建properties查询路径  
                 xref.setNamespaceURIs(nsMap);//设置命名空间  
                  
                 List<Element> propertys = xref.selectNodes(element); 
                 for(Element property : propertys){ 
                     PropertyInformation propertyInformation = new PropertyInformation(); 
                     propertyInformation.setName(property.attributeValue("name")); 
                     propertyInformation.setRef(property.attributeValue("ref")); 
                     propertyInformation.setValue(property.attributeValue("value")); 
                     beanInformation.getPropertyInformation().add(propertyInformation); 
                 } 
                 beansInformation.add(beanInformation); 
             } 
         } catch(Exception e){ 
             e.printStackTrace(); 
         } 
     } 
      
     public void initBean(){ 
         for(BeanInformation beanInformation: beansInformation){ 
             if(beanInformation.getName()!=null && !"".equals(beanInformation.getName())){ 
                 //通过反射机制，根据名字初始化这个类  
                try { 
                    singleton.put(beanInformation.getId(), Class.forName(beanInformation.getName()).newInstance()); 
                } catch (Exception e) { 
                    e.printStackTrace(); 
                } 
             } 
         } 
     } 
      
     /**
     *    关于注入的实现
     */ 
    private void injectObject() { 
        for(BeanInformation beanInformation : beansInformation){ 
            Object bean = singleton.get(beanInformation.getId()); 
            if(bean!=null){ 
                try { 
                    PropertyDescriptor[] ps = Introspector.getBeanInfo(bean.getClass()).getPropertyDescriptors(); 
                    for(PropertyInformation propertyInformation : beanInformation.getPropertyInformation()){ 
                        for(PropertyDescriptor properdesc : ps){ 
                            if(propertyInformation.getName().equals(properdesc.getName())){ 
                                Method setter = properdesc.getWriteMethod();//获取属性的setter方法 ,private  
                                if(setter!=null){ 
                                    Object value = null; 
                                    if(propertyInformation.getRef()!=null && !"".equals(propertyInformation.getRef().trim())){ 
                                        value = singleton.get(propertyInformation.getRef()); 
                                    }else{ 
                                        value = ConvertUtils.convert(propertyInformation.getValue(), properdesc.getPropertyType()); 
                                    } 
                                    setter.setAccessible(true); 
                                    setter.invoke(bean, value);//把引用对象注入到属性  
                                } 
                                break; 
                            } 
                        } 
                    } 
                } catch (Exception e) { 
                } 
            } 
        } 
    } 
     
     public Object getBean(String id){ 
         return this.singleton.get(id);       
     } 
} 

package junit.test;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.beanutils.ConvertUtils;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.XPath;
import org.dom4j.io.SAXReader;
public class ApplicationContext {
     List<BeanInformation> beansInformation = new ArrayList<BeanInformation>();
     Map<String,Object> singleton = new HashMap<String,Object>();
    
    
     public ApplicationContext(){};
     public ApplicationContext(String filename){
      readXml(filename);
      initBean();
      this.injectObject();
     }
     public void readXml(String filename){
      SAXReader saxReader = new SAXReader();
      Document document = null;
      try{
          //使用反射机制,通过文件名加载文件路径
       URL xmlPath = this.getClass().getClassLoader().getResource(filename);
      
       //通过文件路径获得这个文件的document对象
       document = saxReader.read(xmlPath);
      
       Map<String,String> nsMap = new HashMap<String,String>();
           nsMap.put("ns","http://www.springframework.org/schema/beans");//加入命名空间
          
           XPath xsub = document.createXPath("//ns:beans/ns:bean");//创建beans/bean查询路径
           xsub.setNamespaceURIs(nsMap);//设置命名空间
     
       //获得所有路径下的节点
       List<Element> beans = xsub.selectNodes(document);//获取文档下所有bean节点
       for(Element element : beans){
        System.out.println(element.attributeValue("id"));
        System.out.println(element.attributeValue("class"));
       
        BeanInformation beanInformation = new BeanInformation();
        beanInformation.setId(element.attributeValue("id"));
        beanInformation.setName(element.attributeValue("class"));
       
        XPath xref = element.createXPath("ns:property");//创建properties查询路径
        xref.setNamespaceURIs(nsMap);//设置命名空间
       
        List<Element> propertys = xref.selectNodes(element);
        for(Element property : propertys){
         PropertyInformation propertyInformation = new PropertyInformation();
         propertyInformation.setName(property.attributeValue("name"));
         propertyInformation.setRef(property.attributeValue("ref"));
         propertyInformation.setValue(property.attributeValue("value"));
         beanInformation.getPropertyInformation().add(propertyInformation);
        }
        beansInformation.add(beanInformation);
       }
         } catch(Exception e){
          e.printStackTrace();
         }
     }
    
     public void initBean(){
      for(BeanInformation beanInformation: beansInformation){
       if(beanInformation.getName()!=null && !"".equals(beanInformation.getName())){
        //通过反射机制，根据名字初始化这个类
       try {
     singleton.put(beanInformation.getId(), Class.forName(beanInformation.getName()).newInstance());
    } catch (Exception e) {
     e.printStackTrace();
    }
       }
      }
     }
    
     /**
   *    关于注入的实现
   */
  private void injectObject() {
   for(BeanInformation beanInformation : beansInformation){
    Object bean = singleton.get(beanInformation.getId());
    if(bean!=null){
     try {
      PropertyDescriptor[] ps = Introspector.getBeanInfo(bean.getClass()).getPropertyDescriptors();
      for(PropertyInformation propertyInformation : beanInformation.getPropertyInformation()){
       for(PropertyDescriptor properdesc : ps){
        if(propertyInformation.getName().equals(properdesc.getName())){
         Method setter = properdesc.getWriteMethod();//获取属性的setter方法 ,private
         if(setter!=null){
          Object value = null;
          if(propertyInformation.getRef()!=null && !"".equals(propertyInformation.getRef().trim())){
           value = singleton.get(propertyInformation.getRef());
          }else{
           value = ConvertUtils.convert(propertyInformation.getValue(), properdesc.getPropertyType());
          }
          setter.setAccessible(true);
          setter.invoke(bean, value);//把引用对象注入到属性
         }
         break;
        }
       }
      }
     } catch (Exception e) {
     }
    }
   }
  }
  
     public Object getBean(String id){
   return this.singleton.get(id);  
     }
}
[java]
package junit.test; 
 
import java.util.HashSet; 
import java.util.Set; 
 
public class BeanInformation { 
    private String id; 
    private String name; 
    private Set<PropertyInformation> propertyInformation = new HashSet<PropertyInformation>(); 
    public String getId() { 
        return id; 
    } 
    public void setId(String id) { 
        this.id = id; 
    } 
    public String getName() { 
        return name; 
    } 
    public void setName(String name) { 
        this.name = name; 
    } 
    public Set<PropertyInformation> getPropertyInformation() { 
        return propertyInformation; 
    } 
    public void setPropertyInformation(Set<PropertyInformation> propertyInformation) { 
        this.propertyInformation = propertyInformation; 
    } 
} 

package junit.test;

import java.util.HashSet;
import java.util.Set;

public class BeanInformation {
    private String id;
    private String name;
    private Set<PropertyInformation> propertyInformation = new HashSet<PropertyInformation>();
 public String getId() {
  return id;
 }
 public void setId(String id) {
  this.id = id;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public Set<PropertyInformation> getPropertyInformation() {
  return propertyInformation;
 }
 public void setPropertyInformation(Set<PropertyInformation> propertyInformation) {
  this.propertyInformation = propertyInformation;
 }
}
[java]
package junit.test; 
 
public class PropertyInformation { 
    private String name; 
    private String ref; 
    private String value; 
    public String getName() { 
        return name; 
    } 
    public void setName(String name) { 
        this.name = name; 
    } 
    public String getRef() { 
        return ref; 
    } 
    public void setRef(String ref) { 
        this.ref = ref; 
    } 
    public String getValue() { 
        return value; 
    } 
    public void setValue(String value) { 
        this.value = value; 
    } 
} 

package junit.test;

public class PropertyInformation {
    private String name;
    private String ref;
    private String value;
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public String getRef() {
  return ref;
 }
 public void setRef(String ref) {
  this.ref = ref;
 }
 public String getValue() {
  return value;
 }
 public void setValue(String value) {
  this.value = value;
 }
}

测试类：

[java]
package junit.test; 
 
import com.huxin.springinject.dao.Person; 
 
public class Test { 
    public static void main(String[] args) { 
        ApplicationContext ac = new ApplicationContext("applicationContext.xml"); 
        Person person = (Person)ac.getBean("chinese"); 
        person.save(); 
        person.useAxe(); 
    } 
} 

package junit.test;

import com.huxin.springinject.dao.Person;

public class Test {
 public static void main(String[] args) {
  ApplicationContext ac = new ApplicationContext("applicationContext.xml");
  Person person = (Person)ac.getBean("chinese");
  person.save();
  person.useAxe();
 }
}

[html]
<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" 
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
       xmlns:context="http://www.springframework.org/schema/context"   
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
           http://www.springframework.org/schema/context  
           http://www.springframework.org/schema/context/spring-context-3.0.xsd"> 
        
       
      <bean id="chinese"  class="com.huxin.springinject.dao.impl.Chinese"> 
         <property name="axe" ref="stoneAxe"/> 
      </bean> 
      <bean id="stoneAxe" class="com.huxin.springinject.dao.impl.StoneAxe"/> 
</beans> 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-3.0.xsd">
      
     
      <bean id="chinese"  class="com.huxin.springinject.dao.impl.Chinese">
         <property name="axe" ref="stoneAxe"/>
      </bean>
      <bean id="stoneAxe" class="com.huxin.springinject.dao.impl.StoneAxe"/>
</beans>

补充说明： 需要导入dom4j相应的辅助包和junit辅助包！


junj5n
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解Spring MVC自动为对象注入枚举类型
08-30
本篇文章主要介绍了Spring MVC自动为对象注入枚举类型，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
学习springmvc的第三天(1:属性注入)
xx2wd的博客
05-03 255
spring的属性注入： 配置文件： Class文件： public class Foo { private String iDCode; public String getiDCode() { return iDCode; } public void setiDCode(String iDCode) { this.iDCode =
spring mvc注入配置文件里的属性
試毅-思伟_技术博客
12-20 380
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <property name="systemPropertiesModeName" value="SYSTEM_PROPERTIES_MODE_OVER...
springmvc注入properties文件属性
Dreams of JAVAD
05-23 1733
properties 通过util注入过程很简单,直接上代码,springcontent配置文件<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframewor
Spring MVC 属性文件读取注入到静态字段
後雪寒的专栏
07-11 4885
在项目中，有些参数需要配置到属性文件xxx.properties中，这样做是为了维护方便，如果需要变动只需修改属性文件，不需要重新编译项目就可以了，非常方便。 而为了使用起来方便，可以通过将属性值注入到类的静态字段中（static），这样就可以用className.fieldName的方式来获取了。 1.servlet-context.xml &lt;!-- spring的属性加载...
浅析依赖注入框架Autofac的使用
09-03
Autofac是一款IOC框架，比起Spring.NET,Unity,Castle等等框架，它很轻量级且性能也很高，下面小编给大家介绍下依赖注入框架Autofac的使用。
手写spring mvc框架
09-22
简单的模板spring mvc框架，实现了实例化controller、service，依赖注入等功能，可以下载学习一下，更加深入理解spring mvc框架
api-algafood:涵盖了Spring Rest专家课程（进行中）技术。 Spring和依赖注入使用针对REST API的主要Spring生态系统项目，例如Spring Framework，Spring MVC，Spring Boot，Spring Data JPA，Spring Security OAuth和Spring HATEOAS。 还了解依赖注入如何与Spring，IoC容器，具有@ Component，@ Configuration和@Bean的bean定义，注入点，与@ Primary
04-13
Spring和依赖注入使用针对REST API的主要Spring生态系统项目，例如Spring Framework，Spring MVC，Spring Boot，Spring Data JPA，Spring Security OAuth和Spring HATEOAS。 还了解依赖注入如何与Spring，IoC容器，...
user-login:简单Spring MVC（实验第2部分）
05-03
用户登录演示 ... 使用Spring会话属性 一些JSP和JSTL Log4j 基本的Spring依赖注入 用法 使用mvn jetty:run启动服务器，点击并尝试有效/无效的登录名。 请注意控制台中的日志以及logins.txt文件中的日志。
Spring基础之属性注入总结
热门推荐
冷血之心的博客
12-26 1万+
（尊重劳动成果，转载请注明出处：http://blog.csdn.net/qq_25827845/article/details/53888749冷血之心的博客） Spring是开源的轻量级框架，核心主要两部分： （1）aop：面向切面编程，扩展功能不是修改源代码实现 （2）ioc：控制反转， - 比如有一个类，在类里面有方法（不是静态的方法），调用类里面的方法，创建类的对象，使用...
3 手写实现SpringMVC，第三节：通过反射给属性和参数注入值
tianyaleixiaowu的专栏
06-30 4832
在上一篇已经完成了读取beanName->Object映射关系的功能，这一篇就是把读取到的映射注入到属性中。 在WebController里定义了需要被Autowired的两个Service，myQueryService和modifyService，下面来给他们赋值。 通过反射给属性赋值
springmvc参数注入
slow444的博客
01-14 1175
SpringMVC参数注入 1.简单参数注入 1.通过key=value方法注入 前端请求 127.0.0.1:8080/user?username=tom&age=12 后端接收时的参数必须也为username和age 如果参数名不统一，既参数不是username或者age则需要通过注解映射 package com.fs.controller; import com.fs.entity.User; import org.springframework.stereotype.Control
springmvc请求参数获取的几种方法
weixin_34384915的博客
07-22 523
1、直接把表单的参数写在Controller相应的方法的形参中，适用于get方式提交，不适用于post方式提交。 /** * 1.直接把表单的参数写在Controller相应的方法的形参中 * @param username * @param password * @return */ @RequestMappi...
Spring学习笔记（二）——注解创建对象和注入属性
啦啦啦的博客
03-12 2704
一、Bean相关的注解 与SpringBean相关的注解有以下四大类： @Component：标注一个普通的Spring Bean类 @Controller：标注一个控制器组件类 @Service：标注一个业务逻辑组件类 @Repository：标注一个DAO组件类 如果我们需要定义一个普通的Spring Bean，那么直接使用@Component标注即可。但如果用@Repository...
啃知识_SpringMVC的controller层@Value注入不进去问题
胜利属于有准备的人
03-15 7752
在项目开发中,近期发现了一个问题.  在controller层的@Value注入不进去properties中配置的数据. 去网上查大家的回答都是说因为SpringMVC中有两个容器.导致问题出现.但是想具体知道什么原因就没有更好的文章了. 经过源码的分析,终于知道了问题所在. 当我们使用Spring的时候,它本身是没有web功能的. 通过SpringMVC从而扩展了Spring的功能. 在使用M
能详细展开讲讲spring,spring mvc ,spring boot的原理吗
最新发布
04-17
Spring MVC则是Spring框架中的一个MVC框架，全称为Spring Model-View-Controller，是一种基于请求和响应的Web开发框架。它通过DispatcherServlet分发请求，使用Handler Mapping定位请求处理器，通过Handler Adapter...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值