装配方式default

spring的自动装配(default-autowire="byName")

2017-03-24 15:55:36

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的装配方式
 参考资料
no
byName和byType
constructor
autodetect
小结

 
 
参考资料 
 
 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注解的参数指定。 
在实际应用中如何使用这些注解呢，就通过一个简单程序来体会一下。
 首先生成包，在包内创建两个接口，分别是UserDao和UserService，在其中声明一个save()方法，再创建两个接口的实现类，分别是UserDaoImpl和UserServiceImpl并实现接口。在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的自动装配(default-autowire="byName")
千次阅读 2014-11-30 22:24:20
一，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中的自动装配(default-autowire="byName")
2013-05-07 08:52:28
自动装配,官方给出的定义是这样: Spring IoC容器可以自动装配（autowire）相互协作bean之间的关联关系。因此，如果可能的话，可以自动让Spring通过检查BeanFactory中的内容，来替我们指定bean的协作者（其他被...
收起
【Spring】spring的自动装配(default-autowire="byName")
千次阅读 2015-11-10 12:03:17
自动装配,官方给出的定义是这样: Spring IoC容器可以自动装配（autowire）相互协作bean之间的关联关系。因此，如果可能的话，可以自动让Spring通过检查BeanFactory中的内容，来替我们指定bean的协作者（其他被依赖...
收起
spring
spring 自动装配 default-autowire="byName/byType
2017-07-13 16:01:08
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的自动装配 default-autowire="byName
2019-01-08 03:19:09
今天来整理一下Spring的自动装配 autowire一节，在这里我们要解决以下问题： §1 什么是自动装配? §2 自动装配的意义? §3 自动装配有几种类型? §4 如何启用自动装配? §5 自动装配将引发的问题? §1 什么是自动...
收起
Spring的五种自动装配方式
2020-05-13 19:23:51
autodetect：如果有默认的构造器，则通过constructor的方式进行自动装配，否则使用byType的方式进行自动装配。自动装配没有自定义装配方式那么精确，而且不能自动装配简单属性（基本类型、字符串等.
收起
spring
【Spring】Spring中的Bean - 5、Bean的装配方式(XML、注解（Annotation）、自动装配)
2020-02-14 22:51:35
Bean的装配方式 简单记录-Java EE企业级应用开发教程（Spring+Spring MVC+MyBatis）-Spring中的Bean 文章目录Bean的装配方式基于XML的装配基于注解（Annotation）的装配自动装配 IoC是Spring框架的核心内容，使用...
收起
Spring 注解
Spring之自动装配的五种方式
千次阅读 2018-08-25 19:01:30
基于xml配置文件中的autowire来实现的spring自动装配，主要有以下五种具体的实现方式： no —— 默认情况，自动装配方式为手动装配，即通过ref手动设定 byName —— 根据属性名称自动装配，如果一个bean的...
收起
Spring
spring的五种自动装配方式
2019-10-23 17:06:06
当Spring装配Bean属性时，有时候非常明确，就是需要将某个Bean的引用装配给指定属性。先写两个类 public class UserServcie { private UserDao userDao; public UserServcie(UserDao userDao){} public ...
收起
Spring自动装配Bean——xml方式与注解方式
2019-09-26 11:38:00
一、自动装配的概念在Spring使用中，我们在xml配置文件通过元素或元素的ref属性向bean注入另外的依赖bean。如果使用自动装配(autowiring) ，就可以减少甚至消除配置元素和元素。设置元素的autowire属性就可以设定...
收起
Spring XML 注解
Spring中自动装配的4种方式
千次阅读 2018-12-24 10:04:55
在Spring中，我们有4中方式可以装配Bean的属性。 1，byName。通过byName方式自动装配属性时，是在定义Bean的时候，在property标签中设置autowire属性为byName，那么Spring会自动寻找一个与该属性名称相同或id相同...
收起
【Spring杂烩】@Enable模块装配的两种实现方式
2019-01-03 12:34:01
Spring中@Enable模块装配的两种实现方式基本概要模块装配脑图什么时候开始支持模块装配什么是模块？什么是模块装配？模块装配的应用模块装配的两种实现方式源码体现自定义模块装配 ...
收起
Spring @Enable
Spring的自动装配方式【4.3.16.RELEASE版】
2018-05-03 13:51:05
摘自官网：... Autowiring modesModeExplanationno(Default) No autowiring. B...
收起
Spring自动装配
2020-11-02 09:25:00
default - 默认的方式和 “no” 方式一样 no - 不自动装配，需要使用节点或参数 byName - 根据名称进行装配 byType - 根据类型进行装配 constructor - 根据构造函数进行装配自动装配的概念 1)手动装配：以value或...
收起
spring java bean

spring的自动装配(default-autowire="byName")

Spring的装配方式

Spring的装配方式

参考资料

no

byName和byType

constructor

autodetect

小结

Bean的装配方式

什么是Bean的装配？

基于XML的装配方式

设值注入

构造注入

基于注解（Annotation）的装配方式

自动装配方式

spring的5种自动装配方式

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

spring的default-lazy-init参数和spring的自动装配(default-autowire="byName")

spring 自动装配 bean 有哪些方式？

Spring中的自动装配(default-autowire="byName")

【Spring】spring的自动装配(default-autowire="byName")

spring 自动装配 default-autowire="byName/byType

Spring自动装配方式介绍

Spring的自动装配 default-autowire="byName

Spring的五种自动装配方式

【Spring】Spring中的Bean - 5、Bean的装配方式(XML、注解（Annotation）、自动装配)

Spring之自动装配的五种方式

spring的五种自动装配方式

Spring自动装配Bean——xml方式与注解方式

Spring中自动装配的4种方式

【Spring杂烩】@Enable模块装配的两种实现方式

Spring的自动装配方式【4.3.16.RELEASE版】

Spring自动装配

装配方式default