精华内容
下载资源
问答
  • spring的自动装配(default-autowire="byName")
    自动装配,官方给出的定义是这样:
    
    Spring IoC容器可以自动装配(autowire)相互协作bean之间的关联关系。因此,如果可能的话,可以自

    动让Spring通过检查BeanFactory中的内容,来替我们指定bean的协作者(其他被依赖的bean)。由于

    autowire可以针对单个bean进行设置,因此可以让有些bean使用autowire,有些bean不采用。autowire的

    方便之处在减少或者消除属性或构造器参数的设置,这样可以给我们的配置文件减减肥

    其实,自动装配就是让我们少些几个  <ref ="...">.

    我们还是从需求出发.我们假设有4个bean.分别是bean2,bean3,bean4,bean5..其中,bean2里面有后面几个

    的引用..我只放出来bean2.java.

    package com.test.model;
    public class Bean2 {

     private Bean3 bean3;

     private Bean4 bean4;
     
     private Bean5 bean5;

     public Bean3 getBean3() {
      return bean3;
     }

     public void setBean3(Bean3 bean3) {
      this.bean3 = bean3;
     }

     public Bean4 getBean4() {
      return bean4;
     }

     public void setBean4(Bean4 bean4) {
      this.bean4 = bean4;
     }

     public Bean5 getBean5() {
      return bean5;
     }

     public void setBean5(Bean5 bean5) {
      this.bean5 = bean5;
     }
    }
    我们看不用自动装配的写法

    <bean id="bean2" class="com.test.model.Bean2">
      <property name="bean3" ref="bean3"/>
      <property name="bean4">
       <ref bean="bean4"/>
      </property> 
      <property name="bean5" ref="bean5"/>
     </bean>

    很明显,下面的几个属性设置是很繁琐的..我们假设使用自动装配.我们只需要这样

    <bean id="bean2" class="com.test.model.Bean2" />

    里面的装配都不用写.

    当然,自动装配必须满足两点

    (1)bean2.java里面的属性名字必须和applicationContext.xml里面对应的bean id的名字相同..也就是

     private Bean3 bean3;  这个bean3(其实对应的是get,set方法)必须和

    <bean id="bean3" class="com.test.model.Bean3"
      parent="abstractBean">
      <property name="name" value="Tom" />
      <property name="password" value="123" />
     </bean>  这个bean3相同.否则不能自动装配

    (2)在申明里配置一个属性.default-autowire="byName"(通过名字自动装配)

    配置文件为.

    <?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-2.0.xsd"
     default-autowire="byName">


     <bean id="abstractBean" abstract="true">
      <property name="id">
       <value>1000</value>
      </property>
      <property name="name" value="java" />
     </bean>
     <bean id="bean2" class="com.test.model.Bean2" />

     <bean id="bean3" class="com.test.model.Bean3"
      parent="abstractBean">
      <property name="name" value="Tom" />
      <property name="password" value="123" />
     </bean>

     <bean id="bean4" class="com.test.model.Bean4" parent="abstractBean" />

     <bean id="bean5" class="com.test.model.Bean5">
      <property name="age" value="20" />
     </bean>

    default-autowire="x"
    x有4个选择:byName,byType,constructor和autodetect
    1. byName:
    Service.java
    public class Service
    {
        Source source;
        public void setSource(Source source)
        {
            this.source = source;
        }
    }
    applicationContext.xml
    <beans
       ...
       default-autowire="byName">
        <bean id="source" class="cn.hh.spring.DBCPSource" scope="prototype"/>
        <bean id="service" class="cn.hh.spring.Service" scope="prototype">
        </bean>
    </beans>
    cn.hh.spring.DBCPSource实现了Source接口
    xml中并没有给 bean service配Source属性,但在beans中设置了autowire="byName",这样配置文件会自

    动根据 cn.hh.spring.Service 中的setSource找bean id="Source"的bean ,然后自动配上去,如果没找

    到就不装配。
    注意:byName的name是java中setXxxx 的Xxxx, 和上面设置的Source source中source拼写毫无关系,完

    全可以是
    public class Service
    {
        Source source1;
        public void setSource(Source source1)
        {
            this.source1 = source1;
        }
    }
    2. byType:
    Service.java同上
    applicationContext.xml
    <beans
       ...
       default-autowire="byType">
        <bean id="dbcpSource" class="cn.hh.spring.DBCPSource" scope="prototype"/>
        <bean id="service" class="cn.hh.spring.Service" scope="prototype">
        </bean>
    </beans>
    同样没有配置setSource,autowire改成 "byType",配置文件会找实现了Source接口的bean,这里 

    cn.hh.spring.DBCPSource 实现了Source接口,所以自动装配,如果没找到则不装配。
    如果同个配制文件中两个bean实现了Source接口,则报错。
    这里的 Type是指setSource(Source source)中参数的类型。
    3. constructor:
    试图在容器中寻找与需要自动装配的bean的构造函数参数一致的一个或多个bean,如果没找到则抛出异常


    4. autodetect:
    首先尝试使用constructor来自动装配,然后再使用byType方式
    展开全文
  • Spring的装配方式

    千次阅读 2019-06-18 13:49:56
    Spring的装配方式参考资料nobyName和byTypeconstructorautodetect小结 参考资料 Spring - bean的autowire属性(自动装配) Spring 自动装配 spring byType和byName 是什么意思 no Spring中默认的方式,它不能...


    参考资料

    Spring - bean的autowire属性(自动装配)
    Spring 自动装配
    spring byType和byName 是什么意思

    no

    Spring中默认的方式,它不能进行自动装配,不采用autowire机制.,需要使用依赖注入,只能用<ref/>标签,手动设置Bean的依赖关系。

     <!--使用bean标签去申明bean-->
        <bean id="waiter" class="com.fang.spring.Waiter" />
        <!--可以保用p标签来注入依赖的bean-->
        <bean id="store" class="com.fang.spring.Store">
        	<property name="waiter" ref="waiter"></property>
        </bean>
        <!-- 下面这种方式要使用p标签xmlns:p="http://www.springframework.org/schema/p" -->
        <!--  
        <bean id="store" class="com.fang.spring.Store" p:waiter-ref="waiter" />
    	-->
    

    byName和byType

    这种两种方式都需要我们在Java类里设置setter方法,不同的是,byName是通过属性的名称(name或者id)自动装配(注入),Spring会在容器中查找名称与bean属性名称一致的bean,并自动注入到bean属性中。例如:beanA有一个属性eat,它的id设置为eat,那么它的setter方法要设置成setEat(E大小写都没事,不过还是要命名规范)。

    这里有点小郁闷,很多人都说在beans标签加这个属性default-autowire=“byName”,但是老是通不过测试,beans标签不允许这个属性的设置,所以只能在bean标签设置了。

    <bean id="waiter" class="com.fang.spring.Waiter" autowire="byName"/>
        <bean id="store" class="com.fang.spring.Store" autowire="byName"/>
    

    补充,在执行<bean id="waiter" class="com.fang.spring.Waiter" autowire="byName"/>这一句的时候, Spring框架将Waiter这个实体类整个编译一下, 看看自己的这个类里面有几个属性(类型是实体类的属性, 不能是简单类型), 然后和ApplicationContext的配置文件一通对比, 如果有bean的id能跟自己的setter方法对上名字, 就把这个bean装载到自己的这个类里面。

    byType则是通过类型自动装配(注入),Spring会在容器中查找类(Class)与bean属性类一致的bean,并自动注入到bean属性中,如果容器中包含多个这个类型的bean,Spring将抛出异常(就是不能存在多个bean的class指向同一个实体,而且都是byType类型注入的)。如果没有找到这个类型的bean,那么注入动作将不会执行。这样说可能很难理解,其实就是和setter方法中的参数类型有关。

    <bean id="waiter" class="com.fang.spring.Waiter" autowire="byType"/>
        <bean id="store" class="com.fang.spring.Store" autowire="byType"/>
        <!--根据配置文件编译Store,里面有Waiter类型,配置文件里有com.fang.spring.Waiter,于是装载-->
        public class Store {
        @SuppressWarnings("unused")
        private Waiter waiter; 
        public Store() {
            System.out.println("士多店被初始化");
        }
        public void setWaiter(Waiter waiter) {
            this.waiter = waiter;
            System.out.println("设置士多店");
        }
      
    }
    

    constructor

    类似于byType,不过是应用于构造器的参数,如果正好有一个Bean与构造器的参数类型相同则可以自动装配,否则会导致错误。

    假设Store有构造函数public Store(Waiter waiter),那么Spring会在容器中查找类型为Store的bean通过构造函数Store(Wai ter waiter)注入到A中。与byType一样,如果存在多个bean类型为Store,则会抛出异常,另外,如果在容器中找不到匹配的类型的bean,将抛出异常,因为Spring无法调用构造函数实例化这个bean。

    <bean id="waiter" class="com.fang.spring.Waiter" autowire="byType"/>
        <bean id="store" class="com.fang.spring.Store" >
        	<constructor-arg name="waiter" ref="waiter"></constructor-arg>
        </bean>
        
        //Store类的构造方法
         public Store(Waiter waiter) {
            System.out.println("士多店被初始化之构造方法");
        }
    

    autodetect

    autodetect其实还是通过constructor或者byType实现的,如果有默认的构造器,则通过constructor的方式进行自动装配,否则使用byType的方式进行自动装配。


    小结

    自动装配没有自定义装配方式那么精确,而且不能自动装配简单属性(基本类型、字符串等),在使用时应注意。另一方面,自动装配功能和手动装配如果同时使用,那么自动装配就不起作用。

    在 Bean 配置文件里设置 autowire 属性进行自动装配将会装配 Bean 的所有属性。 然而, 若只希望装配个别属性时,autowi re 属性就不够灵活了.。autowire 属性要么根据类型自动装配,,要么根据名称自动装配,不能两者兼而有之。

    Spring4.0新出了很多注解,通过注解的方式可以简化配置文件定义bean的方式,如通过@Configuration注解定义Bean。

    展开全文
  • Bean的装配方式

    千次阅读 2019-05-02 18:49:25
    Spring容器支持多种形式的Bean装配方式,如基于XML的装配 , 基于注解(Annotation)的装配方式 以及 自动装配方式 ,其中最为常用的是基于注解的装配方式 。 基于XML的装配方式 基于XML的装配方式有两种,一种是...

    什么是Bean的装配?

    Bean的装配可以理解为依赖关系注入,Bean的装配方式即Bean依赖注入的方式。Spring容器支持多种形式的Bean装配方式,如基于XML的装配基于注解(Annotation)的装配方式 以及 自动装配方式 ,其中最为常用的是基于注解的装配方式

    基于XML的装配方式

    基于XML的装配方式有两种,一种是设值注入 另一种是构造注入 ,他们分别有不同的使用条件。

    设值注入

    设值注入要求想要实例化Bean对象的类必须要有一个无参的构造方法,以及在类中必须为属性提供setter方法。在配置文件中,通过使用property 元素来为每个属性注入值。

    首先生成一个类,类名命名为User ,为其设置属性,提供所有属性的setter 方法,再为其提供一个无参构造方法

    package beginner.assemble;
    
    import java.util.List;
    
    public class User {
    	private String username;
    	private Integer password;
    	private List<String> list;
    
    	public User() {
    		super();
    	}
    
    	public void setUsername(String username) {
    		this.username = username;
    	}
    
    	public void setPassword(Integer password) {
    		this.password = password;
    	}
    
    	public void setList(List<String> list) {
    		this.list = list;
    	}
    
    	@Override
    	public String toString() {
    		return "User [username=" + username + ", password=" + password + ", list=" + list + "]";
    	}
    
    }
    
    

    在配置文件中进行Bean的配置,使用property元素设置属性值,property元素的name属性值与类中定义属性相同,value为想要设置的值。

    <?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-4.3.xsd">
            
    	<!-- 设值注入 -->
    	<bean id="user2" class="beginner.assemble.User">
    		<property name="username" value="lisi" />
    		<property name="password" value="123456" />
    		<property name="list">
    			<list>
    				<value>"setlistvalue1"</value>
    				<value>"setlistvalue2"</value>
    			</list>
    		</property>
    
    	</bean>
    </beans>
    

    编写测试方法

    package beginner.assemble;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class XmlBeanAssembleTest {
    	public static void main(String[] args) {
    	
    		String xmlpath = "beginner/assemble/assemble.xml";
    		
    		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlpath);
    		
    		System.out.println(applicationContext.getBean("user2"));
    	}
    
    }
    

    运行结果
    在这里插入图片描述

    构造注入

    构造注入要求Bean类必须提供带所有参数的有参的构造方法 ,在配置文件中不再使用property元素来为参数注入值,而是使用constructor-arg 元素来为参数注入值。
    使用设值注入所写的User类,在其中添加将所有属性作为参数的有参构造方法。

    package beginner.assemble;
    
    import java.util.List;
    
    public class User {
    	private String username;
    	private Integer password;
    	private List<String> list;
    
    	public User(String username, Integer password, List<String> list) {
    		super();
    		this.username = username;
    		this.password = password;
    		this.list = list;
    	}
    
    	public User() {
    		super();
    	}
    
    	public void setUsername(String username) {
    		this.username = username;
    	}
    
    	public void setPassword(Integer password) {
    		this.password = password;
    	}
    
    	public void setList(List<String> list) {
    		this.list = list;
    	}
    
    	@Override
    	public String toString() {
    		return "User [username=" + username + ", password=" + password + ", list=" + list + "]";
    	}
    
    }
    

    使用设置输入的配置文件,加入构造注入的配置信息,constructor-arg元素的index属性遍历类中所定义的属性,index属性值从0开始,使用value属性为属性注入值。

    <?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-4.3.xsd">
    	<!--构造注入 -->
    	<bean id="user1" class="beginner.assemble.User">
    		<constructor-arg index="0" value="zhangsan" />
    		<constructor-arg index="1" value="123456" />
    		<constructor-arg index="2">
    			<list>
    				<value>"contructorvalue1"</value>
    				<value>"contructorvalue2"</value>
    			</list>
    		</constructor-arg>
    	</bean>
    
    	<!-- 设值注入 -->
    	<bean id="user2" class="beginner.assemble.User">
    		<property name="username" value="lisi" />
    		<property name="password" value="123456" />
    		<property name="list">
    			<list>
    				<value>"setlistvalue1"</value>
    				<value>"setlistvalue2"</value>
    			</list>
    		</property>
    
    	</bean>
    </beans>
    

    在测试类中添加一条输出语句

    package beginner.assemble;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class XmlBeanAssembleTest {
    	public static void main(String[] args) {
    	
    		String xmlpath = "beginner/assemble/assemble.xml";
    		
    		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlpath);
    	
    		System.out.println(applicationContext.getBean("user1"));
    		
    		System.out.println(applicationContext.getBean("user2"));
    	}
    
    }
    

    运行结果
    在这里插入图片描述

    基于注解(Annotation)的装配方式

    由于基于XML的装配方式会导致配置文件过于臃肿,为后期维护和升级工作带来不便。为此,Spring提供了对注解技术的全面支持。其中主要的注解有:
    1.@Component:用于描述Spring中的Bean,它是一个泛化的概念,仅仅表示一个组件。
    2.@Repository:用于将数据访问层(DAO)的类标识为Spring中的Bean。
    3.@Service:用于将业务层(Service)的类标识为Spring中的Bean。
    4.@Controller:用于将控制层(Controller)的类标识为Spring中的Bean。
    5.@Autowired:用于对Bean的属性变量,属性的setter方法及构造方法进行标注,配合对应的注解处理器完成Bean的自动配置工作。
    6.@Resource:其作用与Autowired一样。@Resource中有两个重要属性:name和type。Spring将name属性解析为Bean实例名称,type属性解析为Bean实例类型。
    7.@Qualifier:与@Autowired注解配合使用,会将默认的按Bean类型装配修改为按Bean的实例名称装配,Bean的实例名称由@Qualifier注解的参数指定。

    在实际应用中如何使用这些注解呢,就通过一个简单程序来体会一下。
    首先生成包,在包内创建两个接口,分别是UserDaoUserService,在其中声明一个save()方法,再创建两个接口的实现类,分别是UserDaoImplUserServiceImpl并实现接口。在UserServiceImpl中依赖UserDaoImpl,并调用UserDaoImpl中的save()方法,再创建一个UserController类,在其中调用UserServiceImpl的save()方法。具体代码如下(**注意,使用注解装配需要在基础的4个核心jar包以及依赖jar包外,再导入Spring aop的jar包):
    UserDao

    package beginner.annotation;
    
    public interface UserDao {
    	public void save();
    
    }
    
    

    UserDaoImpl

    package beginner.annotation;
    
    import org.springframework.stereotype.Repository;
    
    @Repository("userDao")
    public class UserDaoImpl implements UserDao {
    
    	@Override
    	public void save() {
    		System.out.println("UserDao  save..");
    
    	}
    
    }
    

    UserService

    package beginner.annotation;
    
    public interface UserService {
    	public void save();
    
    }
    
    

    UserServiceImpl

    package beginner.annotation;
    
    import javax.annotation.Resource;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    @Service("userService")
    public class UserServiceImpl implements UserService {
    
    	@Resource(name = "userDao")
    	private UserDao userdao;
    
    	@Override
    	public void save() {
    		this.userdao.save();
    		System.out.println("userService   save...");
    
    	}
    
    }
    
    

    UserController

    package beginner.annotation;
    
    import javax.annotation.Resource;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    
    @Controller("userController")
    public class UserController {
    	@Resource(name = "userService")
    	private UserService userService;
    
    	public void save() {
    		this.userService.save();
    		System.out.println("userService  save...");
    	}
    
    }
    
    

    编写配置文件,使用context命名空间,将第2行的 xmlns=“http://www.springframework.org/schema/beans” 复制一行,将其中的beans改为context,在xmlns后加上:context。将第4,5行复制,将beans改为context。
    更改前

    <?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-4.3.xsd">
    </beans>
    

    更改后

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:context="http://www.springframework.org/schema/context"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context-4.3.xsd
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
    </beans>
    

    更改之后既可以使用context命名空间。

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:context="http://www.springframework.org/schema/context"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context-4.3.xsd
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
    
        <context:annotation-config />
    	<bean id="userDao" class="beginner.annotation.UserDaoImpl" />
    	<bean id="userService" class="beginner.annotation.UserServiceImpl" />
    	<bean id="userController"
    		class="beginner.annotation.UserController" />   
    
    </beans>
    

    在配置文件中开启相应的注解处理器。即 <context:annotation-config />
    编写测试类:

    package beginner.annotation;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class AnnotationAssembleTest {
    	public static void main(String[] args) {
    		String xmlPath = "beginner/annotation/annotation.xml";
    		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
    		UserController userController = (UserController) applicationContext.getBean("userController");
    		userController.save();
    
    	}
    
    }
    
    

    最终运行结果:
    在这里插入图片描述
    此程序还可以进行更改,比如在配置文件中,无需配置,只需要自动扫描包即可完成装配工作,代码如下:

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:context="http://www.springframework.org/schema/context"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context-4.3.xsd
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
            
            <context:component-scan base-package="beginner.annotation" />
            
    </beans>
    

    或者将所使用的@Resource注解改为@Autowired,也同样可以完成装配工作。

    自动装配方式

    所谓自动装配,就是将一个Bean自动的装配到其他Bean的Property中。Spring的bean元素包含有一个autowrite属性,我们可以通过设置autowrite的属性值来完成自动装配Bean。
    autowrite的5个属性值:
    1.default(默认值):由bean的上级标签beans的default-autowrite属性值确定。
    2.byName:根据属性的名称自动装配。容器将根据名称查找与属性完全一致的Bean,并将其属性自动装配。
    3.byType:根据属性的数据类型自动装配。如果一个Bean的数据类型,兼容另一个Bean中属性的数据类型,则自动装配。
    4.constructor:根据构造函数参数的数据类型,进行byType模式的自动装配。
    5.no:默认情况下,不使用自动装配,Bean依赖必须通过ref元素定义。

    展开全文
  • spring的5种自动装配方式

    万次阅读 2018-06-10 18:51:22
    set注入和构造注入有时在做配置时比较麻烦。所以框架为了提高开发效率,...标签的autowire属性自动装配属性的5种选择: 1,no不支持自动装配功能2,default表示默认采用上一级标签的自动装配的取值。如果存在多个配...

    set注入和构造注入有时在做配置时比较麻烦。所以框架为了提高开发效率,提供自动装配功能,简化配置。Spring框架式默认不支持自动装配的,要想使用自动装配需要修改spring配置文件中<bean>标签的autowire属性

     自动装配属性的5种选择:

     

     

                   

     

    1,no

     不支持自动装配功能

     

    2,default

     表示默认采用上一级标签的自动装配的取值。如果存在多个配置文件的话,那么每一个配置文件的自动装配方式都是独立的。

     

    3,byName

     从Spring环境中获取目标对象时,目标对象中的属性会根据名称在整个Spring环境中查找<bean>标签的id属性值。如果有相同的,那么获取这个对象,实现关联。

    注:整个Spring环境:表示所有的spring配置文件中查找,那么id不能有重复的               

     

    4,constructor

     使用构造方法完成对象注入,其实也是根据构造方法的参数类型进行对象查找,相当于采用byType的方式。

     

     

    5,byType

     从Spring环境中获取目标对象时,目标对象中的属性会根据类型在整个spring环境中查找<bean>标签的class属性值。如果有相同的,那么获取这个对象,实现关联。

     

     缺点:如果存在多个相同类型的bean对象,会出错。

         如果属性为单一类型的数据,那么查找到多个关联对象会发生错误。

    如果属性为数组或集合(泛型)类型,那么查找到多个关联对象不会发生异常。
     

    注:自动装配功能和手动装配要是同时使用,那么自动装配就不起作用。在 Bean 配置文件里设置 autowire 属性进行自动装配将会装配 Bean 的所有属性。 然而, 若只希望装配个别属性时,autowire 属性就不够灵活了.。
    autowire 属性要么根据类型自动装配,,要么根据名称自动装配,不能两者兼而有之。

     

     

     

     

    我的座右铭:不会,我可以学;落后,我可以追赶;跌倒,我可以站起来;我一定行。

    展开全文
  • 一,spring的default-lazy-init参数 spring在启动的时候,会默认加载会默认加载整个对象实例图,从初始化ACTION配置、到 service配置到dao配置、乃至到数据库连接、事务等等。这样可以减少web服务器在运行时的...
  • spring 自动装配 bean 有哪些方式

    万次阅读 2019-07-17 10:59:39
    spring 自动装配 bean 有哪些方式?...default - 默认的方式和 "no" 方式一样 no - 不自动装配,需要使用 <ref />节点或参数 byName - 根据名称进行装配 byType - 根据类型进行装配 constructo...
  • 自动装配,官方给出的定义是这样: Spring IoC容器可以自动装配(autowire)相互协作bean之间的关联关系。因此,如果可能的话,可以自 动让Spring通过检查BeanFactory中的内容,来替我们指定bean的协作者(其他被...
  • 自动装配,官方给出的定义是这样: Spring IoC容器可以自动装配(autowire)相互协作bean之间的关联关系。因此,如果可能的话,可以自动让Spring通过检查BeanFactory中的内容,来替我们指定bean的协作者(其他被依赖...
  • pre name="code" class="html">spring 自动装配 default-autowire="byName/byType" 一、spring 自动装配 default-autowire="byName" byName,按变量名称,与id名称一样,若不一样,就报错。 xml version=...
  • Spring自动装配方式介绍

    千次阅读 2018-06-01 18:39:08
    自动装配是Spring框架的重要功能,是使用Spring满足bean依赖的一种方式,Spring会在应用中为某个bean寻找其依赖的bean,Spring中bean有三种装配机制,分别是:在xml中显示配置、在java中显示配置以及隐式的bean发现....
  • 今天来整理一下Spring的自动装配 autowire一节,在这里我们要解决以下问题: §1 什么是自动装配? §2 自动装配的意义? §3 自动装配有几种类型? §4 如何启用自动装配? §5 自动装配将引发的问题? §1 什么是自动...
  • autodetect:如果有默认的构造器,则通过constructor的方式进行自动装配,否则使用byType的方式进行自动装配。 自动装配没有自定义装配方式那么精确,而且不能自动装配简单属性(基本类型、字符串等.
  • Bean的装配方式 简单记录-Java EE企业级应用开发教程(Spring+Spring MVC+MyBatis)-Spring中的Bean 文章目录Bean的装配方式基于XML的装配基于注解(Annotation)的装配自动装配 IoC是Spring框架的核心内容,使用...
  • Spring之自动装配的五种方式

    千次阅读 2018-08-25 19:01:30
    基于xml配置文件中的autowire来实现的spring自动装配,主要有以下五种具体的实现方式: no —— 默认情况,自动装配方式为手动装配,即通过ref手动设定 byName —— 根据属性名称自动装配,如果一个bean的...
  • 当Spring装配Bean属性时,有时候非常明确,就是需要将某个Bean的引用装配给指定属性。 先写两个类 public class UserServcie { private UserDao userDao; public UserServcie(UserDao userDao){} public ...
  • 一、自动装配的概念 在Spring使用中,我们在xml配置文件通过元素或元素的ref属性向bean注入另外的依赖bean。 如果使用自动装配(autowiring) ,就可以减少甚至消除配置元素和元素。 设置元素的autowire属性就可以设定...
  • Spring中自动装配的4种方式

    千次阅读 2018-12-24 10:04:55
    在Spring中,我们有4中方式可以装配Bean的属性。 1,byName。 通过byName方式自动装配属性时,是在定义Bean的时候,在property标签中设置autowire属性为byName,那么Spring会自动寻找一个与该属性名称相同或id相同...
  • Spring中@Enable模块装配的两种实现方式 基本概要 模块装配脑图 什么时候开始支持模块装配 什么是模块?什么是模块装配? 模块装配的应用 模块装配的两种实现方式 源码体现 自定义模块装配 ...
  • 摘自官网:... Autowiring modesModeExplanationno(Default) No autowiring. B...
  • Spring自动装配

    2020-11-02 09:25:00
    default - 默认的方式和 “no” 方式一样 no - 不自动装配,需要使用 节点或参数 byName - 根据名称进行装配 byType - 根据类型进行装配 constructor - 根据构造函数进行装配 自动装配的概念 1)手动装配:以value或...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,072
精华内容 13,228
关键字:

装配方式default