精华内容
下载资源
问答
  • spring依赖注入

    千次阅读 2016-05-12 16:36:40
    依赖注入的英文名Dependency Injection。...so,依赖注入的作用就是使用spring框架创建对象时,动态的将所依赖的对象注入到Bean组件中。 说到依赖注入,实现方式有3中,分别是setter方法注入、构造方法注入

    依赖注入的英文名Dependency Injection。与ioc差不多,不过是从两个角度描述同一个概念。举个栗子,一个对象A需要使用对象B来完成某个功能,可以说A依赖B,spring会在创建A时自动将B对象注入A对象。so,依赖注入的作用就是使用spring框架创建对象时,动态的将所依赖的对象注入到Bean组件中。


    说到依赖注入,实现方式有3中,分别是setter方法注入、构造方法注入和接口注入。


    属性setter注入:ioc容器使用setter方法来注入被依赖的对象。通过调用无参构造器或者无参的static工厂方法实例化Bea后,调用Bean的setter方法,实现基于setter的依赖注入。

    构造方法注入:使用构造方法来注入所依赖的实例。

    接口注入:spring容器不支持接口注入。


    今天玩的是setter注入。通过servi层调用Dao层来模拟依赖注入。

    public class BookDao 
    {
    	public void save()
    	{
    		System.out.println("add Book");
    	}
    }

    public class BookService 
    {
    	private BookDao bookDao;//所依赖的对象
    	
    	public void setBookDao(BookDao bookDao)//用于setter注入
    	{
    		this.bookDao = bookDao;
    	}
    	
    	
    	public void addBook()
    	{
    		bookDao.save();
    	}
    }
    

    配置xml,xml的位置可以放到bean所在的目录i

    <?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">
    
    	<bean id="bookDaoId" class="com.canyugan.di.BookDao"/>
    	<bean id="bookServiceId" class="com.canyugan.di.BookService">
    		<!-- <property> 进行依赖注入过程,底层将执行setter方法
    			* name 对象的属性, setBookDao -> BookDao -> bookDao
    			* ref 其他对象实例引用
    		 -->
    		 <!-- has a -->
    		<property name="bookDao" ref="bookDaoId"></property>
    	</bean>
    </beans>

    测试我们的setter注入


    @Test
    	public  void demo1()
    	{ 
    		//加载配置文件
    		ApplicationContext applicationContext=new ClassPathXmlApplicationContext("com/canyugan/di/beans.xml");
    		//从spring的工厂中获取对象
    		BookService bookService=applicationContext.getBean("bookServiceId",BookService.class);
    		bookService.addBook();
    	}


    可以看到,成功的添加了一本书。


    欣赏一下,spring的setter注入。

    展开全文
  • Spring 依赖注入

    千次阅读 2018-01-09 22:43:45
    依赖注入(Dependency Injection,简称DI)与控制反转(IoC)的含义相同。 当某个java对象(调用者)需要调用另一个java对象(被调用用者,即被依赖对象)时,调用者采用new 被调用者 的方式创建对象,这样就会导致...

    依赖注入(Dependency Injection,简称DI)与控制反转(IoC)的含义相同。

    当某个java对象(调用者)需要调用另一个java对象(被调用用者,即被依赖对象)时,调用者采用new 被调用者 的方式创建对象,这样就会导致调用者与被调用者之间的耦合性增加,不利于后期项目的升级和维护。

    使用Spring框架后,对象不再由调用者来创建,而是由Spring容器创建,Spring容器会负责控制器程序之间的关系,而不是由调用者的程序代码直接控制。这样控制权由应用代码转移到了Spring容器,控制权发生了反转,就是Spring的控制反转。

    实现方式

    1.创建接口

     package com.itheima.ioc;

    public interface UserService {

         public void say();
    }

    2. 创建实现接口类

    package com.itheima.ioc;

    public class UserServiceImpl implements UserService {
        private UserDao userDao;
        public void setUserDao(UserDao userDao)
        {
            this.userDao = userDao;
        }
        public void say(){
            this.userDao.say();
            System.out.println("userService say hello world!");
        }
    }

    3.设置配置文件

    <?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="userDao" class="com.itheima.ioc.UserDaoImpI">
            <!-- collaborators and configuration for this bean go here -->
        </bean>
        <bean id="userService" class="com.itheima.ioc.UserServiceImpl">
           <property name="userDao" ref ="userDao"></property>
            <!-- collaborators and configuration for this bean go here -->
        </bean>

    </beans>

    4创建测试类

    package com.itheima.ioc;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    public class TestDI {
        private static ApplicationContext applicationContext;
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
            UserService  userService = (UserService)applicationContext.getBean("userService");
            userService.say();
            }
        
    }

    5.执行运行后,控制台输出



    展开全文
  • Spring依赖注入

    千次阅读 热门讨论 2014-09-27 23:14:42
    依赖注入或者说是控制反转,说白了就是使用了配置文件,这种思想的唯一好处就是增加了模块的重用性灵活性。下面介绍几种依赖注入的方式:

        依赖注入或者说是控制反转,说白了就是使用了配置文件,这种思想的最大的好处就是增加了模块的重用性灵活性。下面介绍几种依赖注入的方式:


    一、Setter注入
         Spring提供的Setter注入是最常用的一种Bean注入法,通过Setter注入后,直接将Bean的属性值输出在页面中

    1.当前Bean对象要注入到哪个对象中,就需要在哪个对象中为当前这个对象设置私有属性,并设置属性的getter返回器和setter设置器。如:User对象注入到TestUtil对象中,那么就需要在TestUtil类中设置User对象属性,并设置getter()setter()方法,TtstUtil类的代码如下:
    public  class TestUtil{
    		private User user;
    		public User getUser(){
    			return user;
    		}
    		
    		public void setUser(User user){
    			this.user=user;
    		}
    	}

    2.Springxml配置文件中,通过<bean>标签对Bean进行依赖注入配置。<bean>标签的属性主要有两个,id属性用于配置Bean的唯一标识,Bean在注入的时需要根据这个标识查找Bean对象;class属性用于指定完整的Bean类。代码如下:
    	<!--为User对象属性赋值 - ->
    	<bean id="user"  class="com.lh.entity.User"/>
    	<!-- 配置TestUtil,注入User -->
    	<bean id="testUtil"  class="com.lh.util.TestUtil">
    		<property  name="user" ref="user"/>
    	</bean>

    二、应用构造器注入法
    类在被实例化的时候,其构造方法将被调用并且只能调用一次。因此构造器常被用于类的初始化操作。
    1.TestUtil类中创建一个构造方法,并传递一个User参数

    public  class TestUtil{
    		private User user;
    		Public TestUtil(User user){ //构造方法
    			This.user =user;
    		}
    		
    		Public boolean getUserInfo(){
    			If(user != null) {
    				Return true;
    			} else{
    				Return false;
    			}
    		}
    	}

          2.Spring中的<constructor-arg><bean>元素的子元素,通过该元素可以实现为当前业务对象注入其所依赖的对象。xml中的配置如下:
    <!--为User对象属性赋值 - ->
    	<bean id="user"  class="com.lh.entity.User"/>
    	<!-- 配置TestUtil,注入User -->
    	<bean id="testUtil"  class="com.lh.util.TestUtil">
    		<constructor-arg >
    			<ref bean="user">
    		</constructor-arg>
    	</bean>
    


    三、应用@Autowired注解实现Bean的注入
            可以利用Spring提供的@Autowired注解实现Bean的注入。@Autowired注解实现依赖注入时,可以标注于以下4种不同的情况。
         (1)可以在类的构造方法上标注@Autowired注解,实现Bean的注入。如:
    	Public class TestUtil{
    		private User user;  //声明要注入的对象
    		
    		@Autowired
    		Public TestUtil(User user){  //构造方法
    			this.user = user;
    		}
    	}

    (2)@Autowired注解标注于属性,实现Bean的注入。在标注属性时,这个属性需要提供gettersetter方法,如:
    Public class TestUtil {
    		@Autowired
    		private User user;
    		
    		public User getUser(){
    			Return user;
    		}  
    		
    		Public void setUser(User user) {
    			this.user =user;
    		}
    	}
    
    

    (3)@Autowired注解标注于setter方法之上,实现Bean的注入,如:
    Public class TestUtil {
    			private User user;
    			
    			public User getUser(){
    				Return user;
    			}  
    			
    			@Autowired
    			Public void setUser(User user) {
    				this.user =user;
    			}
    
    }

    (4)@Autowired注解标注于任意方法之上(只要改方法定义了需要被注入的参数即可实现Bean的注入)
    Public class TestUtil {
    		private User user;
    		
    		@Autowired
    		Public void setUser(User user) {
    			this.user =user;
    		}
    	}


    四、应用@Resource注解实现Bean的注入
    @Resource@Autowired注解类似,除了可以直接在属性域上标注@Resource,还可以在构造方法或者普通方法定义标注@Resource
    1.TestUtil类中将@Autowired注解修改为@Resource注解,如
    	Public class TestUtil {
    		@Resource(name="book")  //指定要注入的对象,book为Spring配置文件中定义的Bean的id
    		Private Book book ;
    		
    		Public Book book;
    		Public Book getBook() {
    			Return book;
    		}
    		
    		Public void setBook(Book book) {
    			this.book =book;
    		}
    	}

    2.然后在Spring的配置文件中队Bean进行配置。针对@Resource注解,在配置文件中还需要配置

    CommonAnnotationBeanPostProcessor,只有这样使用的@Resource注解发挥作用。如:

    <beans>
    	<bean  class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor"/>
    	<!-- 配置User对象 -->
    	<bean id="book"  class="com.lh.util.Book"/>
    	<!-- 配置TestUtil -->
    	<bean id="testUtil"  class="com.lh.util.TestUtil"/>
    </beans>

    不管是使用@Resource@Autowired注解,都需要添加相应的BeanPostProcessor容器,但如果使用

    <context:annotation-config>的话,就不必配置BeanPostProcessor了,因为<context:annotation-config>已经把

    AutowiredAnnotationBeanPostProcessCommonAnnotationBeanPostProcessor注册到容器了。


    小结:
        Spring通过一种称作控制反转(IoC)的技术促进了松耦合。当应用了IoC,一个对象依赖的其它对象会通过被动的方式传递进来,而不是这个对象自己创建或者查找依赖对象。我们可以认为IoC与JNDI相反——不是对象从容器中查找依赖,而是容器在对象初始化时不等对象请求就主动将依赖传递给它。

    展开全文
  • Spring依赖注入与自动装配

    万次阅读 2021-02-06 11:13:29
    Spring依赖注入与自动装配 首先推荐狂神说的Spring讲义 1.Beans.xml作用 简而言之,我们通过在beans.xml中进行配置,将各种类交给spring来管理。 2.依赖注入 推荐狂神说Spring03:依赖注入(DI) 这要从控制反转说起...

    Spring依赖注入与自动装配

    首先推荐狂神说的Spring讲义

    1.Beans.xml作用

    简而言之,我们通过在beans.xml中进行配置,将各种类交给spring来管理。

    2.依赖注入

    推荐狂神说Spring03:依赖注入(DI)

    这要从控制反转说起,控制反转是一种通过描述(XML或注解)并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器,其实现方法是依赖注入(Dependency Injection,DI)。所谓的IoC,一句话搞定 : 对象由Spring 来创建 , 管理 , 装配 !
    常用的注入方式主要有三种:构造方法注入,setter注入(必须有set方法),基于注解的注入。其中注解最为常用。

    2.1构造方法注入

    先简单了解一下测试项目的结构,用maven构建的,四个包:

    1. entity:存储实体,里面只有一个User类 dao:
    2. 数据访问,一个接口,两个实现类
    3. service:服务层,一个接口,一个实现类,实现类依赖于IUserDao
    4. test:测试包

    在spring的配置文件中注册UserService,将UserDaoJdbc通过constructor-arg标签注入到UserService的某个有参数的构造方法

    <!-- 注册userService -->
    <bean id="userService" class="com.lyu.spring.service.impl.UserService">
    	<constructor-arg ref="userDaoJdbc"></constructor-arg>
    </bean>
    <!-- 注册jdbc实现的dao -->
    <bean id="userDaoJdbc" class="com.lyu.spring.dao.impl.UserDaoJdbc"></bean>
    

    如果只有一个有参数的构造方法并且参数类型与注入的bean的类型匹配,那就会注入到该构造方法中。

    public class UserService implements IUserService {
    
    	private IUserDao userDao;
    	
    	public UserService(IUserDao userDao) {
    		this.userDao = userDao;
    	}
    	
    	public void loginUser() {
    		userDao.loginUser();
    	}
    
    }
    
    @Test
    public void testDI() {
    	ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
    	// 获取bean对象
    	UserService userService = ac.getBean(UserService.class, "userService");
    	// 模拟用户登录
    	userService.loginUser();
    }
    
    

    测试打印结果:jdbc-登录成功

    注:模拟用户登录的loginUser方法其实只是打印了一条输出语句,jdbc实现的类输出的是:jdbc-登录成功,mybatis实现的类输出的是:mybatis-登录成功。

    问题一:如果有多个有参数的构造方法并且每个构造方法的参数列表里面都有要注入的属性,那userDaoJdbc会注入到哪里呢?

    public class UserService implements IUserService {
    
    	private IUserDao userDao;
    	private User user;
    	
    	public UserService(IUserDao userDao) {
    		System.out.println("这是有一个参数的构造方法");
    		this.userDao = userDao;
    	}
    	
    	public UserService(IUserDao userDao, User user) {
    		System.out.println("这是有两个参数的构造方法");
    		this.userDao = userDao;
    		this.user = user;
    	}
    	
    	public void loginUser() {
    		userDao.loginUser();
    	}
    
    }
    
    

    结果:会注入到只有一个参数的构造方法中,并且经过测试注入哪一个构造方法与构造方法的顺序无关
    在这里插入图片描述

    问题二:如果只有一个构造方法,但是有两个参数,一个是待注入的参数,另一个是其他类型的参数,那么这次注入可以成功吗?

    public class UserService implements IUserService {
    
    	private IUserDao userDao;
    	private User user;
    	
    	public UserService(IUserDao userDao, User user) {
    		this.userDao = userDao;
    		this.user = user;
    	}
    	
    	public void loginUser() {
    		userDao.loginUser();
    	}
    
    }
    

    结果:失败了,即使在costract-arg标签里面通过name属性指定要注入的参数名userDao也会失败.
    在这里插入图片描述
    问题三:如果我们想向有多个参数的构造方法中注入值该在配置文件中怎么写呢?

    public class UserService implements IUserService {
    
    	private IUserDao userDao;
    	private User user;
    	
    	public UserService(IUserDao userDao, User user) {
    		this.userDao = userDao;
    		this.user = user;
    	}
    	
    	public void loginUser() {
    		userDao.loginUser();
    	}
    
    }
    

    参考写法:通过name属性指定要注入的值,与构造方法参数列表参数的顺序无关。

    <!-- 注册userService -->
    <bean id="userService" class="com.lyu.spring.service.impl.UserService">
    	<constructor-arg name="userDao" ref="userDaoJdbc"></constructor-arg>
    	<constructor-arg name="user" ref="user"></constructor-arg>
    </bean>
    
    <!-- 注册实体User类,用于测试 -->
    <bean id="user" class="com.lyu.spring.entity.User"></bean>
    
    <!-- 注册jdbc实现的dao -->
    <bean id="userDaoJdbc" class="com.lyu.spring.dao.impl.UserDaoJdbc"></bean>
    

    问题四:如果有多个构造方法,每个构造方法只有参数的顺序不同,那通过构造方法注入多个参数会注入到哪一个呢?

    public class UserService implements IUserService {
    
    	private IUserDao userDao;
    	private User user;
    	
    	public UserService(IUserDao userDao, User user) {
    		System.out.println("这是第二个构造方法");
    		this.userDao = userDao;
    		this.user = user;
    	}
    	
    	public UserService(User user, IUserDao userDao) {
    		System.out.println("这是第一个构造方法");
    		this.userDao = userDao;
    		this.user = user;
    	}
    	
    	public void loginUser() {
    		userDao.loginUser();
    	}
    
    }
    

    结果:哪个构造方法在前就注入哪一个,这种情况下就与构造方法顺序有关。
    在这里插入图片描述

    2.2setter注入(需要set方法)

    配置文件如下:

    <!-- 注册userService -->
    <bean id="userService" class="com.lyu.spring.service.impl.UserService">
    	<!-- 写法一 -->
    	<!-- <property name="UserDao" ref="userDaoMyBatis"></property> -->
    	<!-- 写法二 -->
    	<property name="userDao" ref="userDaoMyBatis"></property>
    </bean>
    
    <!-- 注册mybatis实现的dao -->
    <bean id="userDaoMyBatis" class="com.lyu.spring.dao.impl.UserDaoMyBatis"></bean>
    
    
    

    注:上面这两种写法都可以,spring会将name值的每个单词首字母转换成大写,然后再在前面拼接上"set"构成一个方法名,然后去对应的类中查找该方法,通过反射调用,实现注入。

    切记:name属性值与类中的成员变量名以及set方法的参数名都无关,只与对应的set方法名有关,下面的这种写法是可以运行成功的

    public class UserService implements IUserService {
    
    	private IUserDao userDao1;
    	
    	public void setUserDao(IUserDao userDao1) {
    		this.userDao1 = userDao1;
    	}
    	
    	public void loginUser() {
    		userDao1.loginUser();
    	}
    
    }
    

    还有一点需要注意:如果通过set方法注入属性,那么spring会通过默认的空参构造方法来实例化对象,所以如果在类中写了一个带有参数的构造方法,一定要把空参数的构造方法写上,否则spring没有办法实例化对象,导致报错。
    在这里插入图片描述

    2.3基于注解的注入

    在介绍注解注入的方式前,先简单了解bean的一个属性autowire,autowire主要有三个属性值:constructor,byName,byType。

    1.constructor:通过构造方法进行自动注入,spring会匹配与构造方法参数类型一致的bean进行注入,如果有一个多参数的构造方法,一个只有一个参数的构造方法,在容器中查找到多个匹配多参数构造方法的bean,那么spring会优先将bean注入到多参数的构造方法中。

    2.byName:被注入bean的id名必须与set方法后半截匹配,并且id名称的第一个单词首字母必须小写,这一点与手动set注入有点不同。

    3.byType:查找所有的set方法,将符合符合参数类型的bean注入。

    下面进入正题:注解方式注册bean,注入依赖

    主要有四种注解可以注册bean,每种注解可以任意使用,只是语义上有所差异:

    1. @Component:可以用于注册所有bean
    2. @Repository:主要用于注册dao层的bean
    3. @Controller:主要用于注册控制层的bean
    4. @Service:主要用于注册服务层的bean

    描述依赖关系主要有两种:

    1.@Resource:java的注解,默认以byName的方式去匹配与属性名相同的bean的id,如果没有找到就会以byType的方式查找,如果byType查找到多个的话,使用@Qualifier注解(spring注解)指定某个具体名称的bean。

    @Resource
    @Qualifier("userDaoMyBatis")
    private IUserDao userDao;
    
    public UserService(){
    	
    }
    

    2.@Autowired:spring注解,默认是以byType的方式去匹配类型相同的bean,如果只匹配到一个,那么就直接注入该bean,无论要注入的 bean 的 name 是什么;如果匹配到多个,就会调用 DefaultListableBeanFactory 的 determineAutowireCandidate 方法来决定具体注入哪个bean。determineAutowireCandidate 方法的内容如下:

    // candidateBeans 为上一步通过类型匹配到的多个bean,该 Map 中至少有两个元素。
    protected String determineAutowireCandidate(Map<String, Object> candidateBeans, DependencyDescriptor descriptor) {
        //  requiredType 为匹配到的接口的类型
       Class<?> requiredType = descriptor.getDependencyType();
       // 1. 先找 Bean 上有@Primary 注解的,有则直接返回
       String primaryCandidate = this.determinePrimaryCandidate(candidateBeans, requiredType);
       if (primaryCandidate != null) {
           return primaryCandidate;
       } else {
           // 2.再找 Bean 上有 @Order,@PriorityOrder 注解的,有则返回
           String priorityCandidate = this.determineHighestPriorityCandidate(candidateBeans, requiredType);
           if (priorityCandidate != null) {
               return priorityCandidate;
           } else {
               Iterator var6 = candidateBeans.entrySet().iterator();
    
               String candidateBeanName;
               Object beanInstance;
               do {
                   if (!var6.hasNext()) {
                       return null;
                   }
    
                   // 3. 再找 bean 的名称匹配的
                   Entry<String, Object> entry = (Entry)var6.next();
                   candidateBeanName = (String)entry.getKey();
                   beanInstance = entry.getValue();
               } while(!this.resolvableDependencies.values().contains(beanInstance) && !this.matchesBeanName(candidateBeanName, descriptor.getDependencyName()));
    
               return candidateBeanName;
           }
       }
    }
    

    determineAutowireCandidate 方法的逻辑是:

    1. 先找 Bean 上有@Primary 注解的,有则直接返回 bean 的 name。
    2. 再找 Bean 上有 @Order,@PriorityOrder 注解的,有则返回 bean 的 name。
    3. 最后再以名称匹配(ByName)的方式去查找相匹配的 bean。

    可以简单的理解为先以 ByType 的方式去匹配,如果匹配到了多个再以 ByName 的方式去匹配,找到了对应的 bean 就去注入,没找到就抛出异常。

    还有一点要注意:如果使用了 @Qualifier 注解,那么当自动装配匹配到多个 bean 的时候就不会进入 determineAutowireCandidate 方法(亲测),而是直接查找与 @Qualifer 指定的 bean name 相同的 bean 去注入,找到了就直接注入,没有找到则抛出异常。

    tips:大家如果认真思考可能会发现 ByName 的注入方式和 @Qualifier 有点类似,都是在自动装配匹配到多个 bean 的时候,指定一个具体的 bean,那它们有什么不同呢?

    ByName 的方式需要遍历,@Qualifier 直接一次定位。在匹配到多个 bean 的情况下,使用 @Qualifier 来指明具体装配的 bean 效率会更高一下。

    3.自动装配

    • 自动装配是使用spring满足bean依赖的一种方法
    • spring会在应用上下文中为某个bean寻找其依赖的bean。

    Spring中bean有三种装配机制,分别是:

    1. 在xml中显式配置;
    2. 在java中显式配置;
    3. 隐式的bean发现机制和自动装配。

    这里我们主要讲第三种:自动化的装配bean。

    Spring的自动装配需要从两个角度来实现,或者说是两个操作:

    1. 组件扫描(component scanning):spring会自动发现应用上下文中所创建的bean;
    2. 自动装配(autowiring):spring自动满足bean之间的依赖,也就是我们说的IoC/DI;

    组件扫描和自动装配组合发挥巨大威力,使得显示的配置降低到最少。

    推荐不使用自动装配xml配置 , 而使用注解 .

    测试环境搭建

    1、新建一个项目

    2、新建两个实体类,Cat Dog 都有一个叫的方法

    public class Cat {
       public void shout() {
           System.out.println("miao~");
      }
    }
    public class Dog {
       public void shout() {
           System.out.println("wang~");
      }
    }
    

    3、新建一个用户类 User

    public class User {
       private Cat cat;
       private Dog dog;
       private String str;
    }
    

    4、编写Spring配置文件

    <?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">
    
       <bean id="dog" class="com.kuang.pojo.Dog"/>
       <bean id="cat" class="com.kuang.pojo.Cat"/>
    
       <bean id="user" class="com.kuang.pojo.User">
           <property name="cat" ref="cat"/>
           <property name="dog" ref="dog"/>
           <property name="str" value="qinjiang"/>
       </bean>
    </beans>
    

    5、测试

    public class MyTest {
       @Test
       public void testMethodAutowire() {
           ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
           User user = (User) context.getBean("user");
           user.getCat().shout();
           user.getDog().shout();
      }
    }
    

    结果正常输出,环境OK

    byName

    autowire byName (按名称自动装配)

    由于在手动配置xml过程中,常常发生字母缺漏和大小写等错误,而无法对其进行检查,使得开发效率降低。

    采用自动装配将避免这些错误,并且使配置简单化。

    测试:

    1、修改bean配置,增加一个属性 autowire=“byName”

    <bean id="user" class="com.kuang.pojo.User" autowire="byName">
       <property name="str" value="qinjiang"/>
    </bean>
    

    2、再次测试,结果依旧成功输出!

    3、我们将 cat 的bean id修改为 catXXX

    4、再次测试, 执行时报空指针java.lang.NullPointerException。因为按byName规则找不对应set方法,真正的setCat就没执行,对象就没有初始化,所以调用时就会报空指针错误。

    小结:

    当一个bean节点带有 autowire byName的属性时。

    1. 将查找其类中所有的set方法名,例如setCat,获得将set去掉并且首字母小写的字符串,即cat。

    2. 去spring容器中寻找是否有此字符串名称id的对象。

    3. 如果有,就取出注入;如果没有,就报空指针异常。

    byType

    autowire byType (按类型自动装配)

    使用autowire byType首先需要保证:同一类型的对象,在spring容器中唯一。如果不唯一,会报不唯一的异常。

    NoUniqueBeanDefinitionException
    

    测试:

    1、将user的bean配置修改一下 : autowire=“byType”

    2、测试,正常输出

    3、在注册一个cat 的bean对象!

    <bean id="dog" class="com.kuang.pojo.Dog"/>
    <bean id="cat" class="com.kuang.pojo.Cat"/>
    <bean id="cat2" class="com.kuang.pojo.Cat"/>
    
    <bean id="user" class="com.kuang.pojo.User" autowire="byType">
       <property name="str" value="qinjiang"/>
    </bean>
    

    4、测试,报错:NoUniqueBeanDefinitionException

    5、删掉cat2,将cat的bean名称改掉!测试!因为是按类型装配,所以并不会报异常,也不影响最后的结果。甚至将id属性去掉,也不影响结果。

    这就是按照类型自动装配!

    使用注解

    使用注解

    jdk1.5开始支持注解,spring2.5开始全面支持注解。

    准备工作:利用注解的方式注入属性。

    1、在spring配置文件中引入context文件头

    xmlns:context="http://www.springframework.org/schema/context"
    
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd
    

    2、开启属性注解支持!

    <context:annotation-config/>
    

    @Autowired

    • @Autowired是按类型自动转配的,不支持id匹配。
    • 需要导入 spring-aop的包!

    测试:

    1、将User类中的set方法去掉,使用@Autowired注解

    public class User {
       @Autowired
       private Cat cat;
       @Autowired
       private Dog dog;
       private String str;
    
       public Cat getCat() {
           return cat;
      }
       public Dog getDog() {
           return dog;
      }
       public String getStr() {
           return str;
      }
    }
    

    2、此时配置文件内容

    <context:annotation-config/>
    
    <bean id="dog" class="com.kuang.pojo.Dog"/>
    <bean id="cat" class="com.kuang.pojo.Cat"/>
    <bean id="user" class="com.kuang.pojo.User"/>
    

    3、测试,成功输出结果!

    【小狂神科普时间】

    @Autowired(required=false) 说明:false,对象可以为null;true,对象必须存对象,不能为null。

    //如果允许对象为null,设置required = false,默认为true
    @Autowired(required = false)
    private Cat cat;
    

    @Qualifier

    • @Autowired是根据类型自动装配的,加上@Qualifier则可以根据byName的方式自动装配
    • @Qualifier不能单独使用。

    测试实验步骤:

    1、配置文件修改内容,保证类型存在对象。且名字不为类的默认名字!

    <bean id="dog1" class="com.kuang.pojo.Dog"/>
    <bean id="dog2" class="com.kuang.pojo.Dog"/>
    <bean id="cat1" class="com.kuang.pojo.Cat"/>
    <bean id="cat2" class="com.kuang.pojo.Cat"/>
    

    2、没有加Qualifier测试,直接报错

    3、在属性上添加Qualifier注解

    @Autowired
    @Qualifier(value = "cat2")
    private Cat cat;
    @Autowired
    @Qualifier(value = "dog2")
    private Dog dog;
    

    测试,成功输出!

    @Resource

    • @Resource如有指定的name属性,先按该属性进行byName方式查找装配;
    • 其次再进行默认的byName方式进行装配;
    • 如果以上都不成功,则按byType的方式自动装配。
    • 都不成功,则报异常。

    实体类:

    public class User {
       //如果允许对象为null,设置required = false,默认为true
       @Resource(name = "cat2")
       private Cat cat;
       @Resource
       private Dog dog;
       private String str;
    }
    

    beans.xml

    <bean id="dog" class="com.kuang.pojo.Dog"/>
    <bean id="cat1" class="com.kuang.pojo.Cat"/>
    <bean id="cat2" class="com.kuang.pojo.Cat"/>
    
    <bean id="user" class="com.kuang.pojo.User"/>
    

    测试:结果OK

    配置文件2:beans.xml , 删掉cat2

    <bean id="dog" class="com.kuang.pojo.Dog"/>
    <bean id="cat1" class="com.kuang.pojo.Cat"/>
    

    实体类上只保留注解

    @Resource
    private Cat cat;
    @Resource
    private Dog dog;
    

    结果:OK

    结论:先进行byName查找,失败;再进行byType查找,成功。

    小结

    @Autowired与@Resource异同:

    1、@Autowired与@Resource都可以用来装配bean。都可以写在字段上,或写在setter方法上。

    2、@Autowired默认按类型装配(属于spring规范),默认情况下必须要求依赖对象必须存在,如果要允许null 值,可以设置它的required属性为false,如:@Autowired(required=false) ,如果我们想使用名称装配可以结合@Qualifier注解进行使用

    3、@Resource(属于J2EE复返),默认按照名称进行装配,名称可以通过name属性进行指定。如果没有指定name属性,当注解写在字段上时,默认取字段名进行按照名称查找,如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是,如果name属性一旦指定,就只会按照名称进行装配。

    它们的作用相同都是用注解方式注入对象,但执行顺序不同。@Autowired先byType,@Resource先byName。

    问题:Spring的@Autowired加到接口上但获取的是实现类?

    原文来自https://blog.csdn.net/weixin_43575868/article/details/104535986

    	/* 类 @Controller注解,会在spring容器中实例化对象 */
    	@Controller
    	public class UserContoller{
    		@Autowired		// 先按类型找,然后按id为属性名去找
    		private UserService userService;
    		//为什么他会拿到userServiceImpl?
    		// @Autowired会帮你按UserService的类型去容器中找唯一bean对象
    		// 1、容器没有该类型的对象:报错
    		// 2、容器中有该类型的唯一bean对象,就将该唯一bean对象赋值给该属性
    		///3、容器中有多个【两个及以上】该类型的唯一bean对象,
    		//     它会再根据该属性名去容器中找,
    		//     看看容器中的哪个bean对象的id值和该属性名一致,
    		//     如果有,就将容器中该对象赋值给该属性,如果没有报错。
    	}	
    	/* 接口  */
    	public interface UserService{}
    	
    	/* 类  @Service注解,会在spring容器中实例化对象 */
    	@Service
    	public class UserServiceImpl implements UserService{}
    1234567891011121314151617181920
    

    为什么他会拿到userServiceImpl?

    @Autowired先按类型找,然后再按id为属性名去找
    他会帮你按UserService的类型去容器中找唯一bean对象

    1. 容器没有该类型的对象:报错
    2. 容器中有该类型的唯一bean对象,就将该唯一bean对象赋值给该属性
    3. 容器中有多个【两个及以上】该类型的唯一bean对象,
      它会再根据该属性名去容器中找,
      看看容器中的哪个bean对象的id值和该属性名一致,
      如果有,就将容器中该对象赋值给该属性,如果没有报错。

    然后通过多态的向上转型就赋值成功。等价于之前手动赋值

    UserService userService = new UserServiceImpl();
    

    问题:同一接口有多个实现类,如何注入?@Resource、@Autowired、@Qualifier

    原文来自https://blog.csdn.net/u010476994/article/details/80986435

    先写一个场景,举例说明:

    1、接口:IAnimal

    public Interface IAnimal{
    
        ......
    
    }
    

    2、实现类:DogImpl ,实现了IAnimal接口。

    @Service("dogImpl")
    
    public class DaoImpl impliments IAnimal{
    
        ...
    
    }
    

    3、业务类:AnimalController

    public class AnimalController {
    
        @Autowired
    
        private IAnimal dogImpl;
    
        ......
    
    }
    

    假如有一个“动物”的接口 IAnimal, DogImpl类实现了接口 IAnimal, 且该接口只有 DogImpl这一个实现类,那么在引用实现类的时候,我们使用的是实现类的接口(像上面程序展示的那样)。Spring会按 byType的方式寻找接口的实现类,将其注入。

    假如有另一个实现类 CatImpl 也实现了接口 IAnimal, 这时候再按上面的方式去引用, 在同时存在两个实现类的情况下,会出现什么情况呢?

    答:会报错。 这是由于 @Autowired 的特性决定的: @Autowired 的注入方式是 byType 注入, 当要注入的类型在容器中存在多个时,Spring是不知道要引入哪个实现类的,所以会报错。

    那么在同一类型拥有多个实现类的时候,如何注入呢?

    答:这种场景下,只能通过 byName 注入的方式。可以使用 @Resource 或 @Qualifier 注解。

    ​ @Resource 默认是按照 byName 的方式注入的, 如果通过 byName 的方式匹配不到,再按 byType 的方式去匹配。所以上面的引用可以替换为:

    public class AnimalController {
    
        @Resource(name="dogImpl")        //实现类1中 @Service注解中标定的名称
    
        private IAnimal dogImpl;
        ......
    
    }
    

    ​ @Qualifier 注解也是 byName的方式,但是与@Resource 有区别,@Qualifier 使用的是 ****类名****。

    public class AnimalController {
    
    
    
        @Qualifier("DaoImpl")        //实现类1的类名。注意区分与@Resource(name="dogImpl") 的区别。
    
        private IAnimal dogImpl;
    
        ......
    
    }
    

    总结:

    1、@Autowired 是通过 byType 的方式去注入的, 使用该注解,要求接口只能有一个实现类。

    2、@Resource 可以通过 byName 和 byType的方式注入, 默认先按 byName的方式进行匹配,如果匹配不到,再按 byType的方式进行匹配。

    3、@Qualifier 注解可以按名称注入, 但是注意是 类名

    展开全文
  • Spring依赖注入示例

    万次阅读 2020-05-29 14:40:50
    在这个教程中,你将学习什么是 Spring 依赖注入,它是如何工作的,以及如何使用它。 什么是依赖注入依赖注入是您必须了解的Spring基础知识之一。 当您创建一个复杂的应用程序时,很可能会有不同的对象一起工作。 ...
  • Spring依赖注入——Spring(2)

    千次阅读 2020-05-23 22:32:30
    Spring依赖注入官方文档 依赖注入的概念: 依赖注入:Dependency Injection。它是 spring 框架核心 ioc 的具体实现。 我们的程序在编写时,通过控制反转,把对象的创建交给了 spring,但是代码中不可能出现没有依赖...
  • Spring依赖注入详解

    千次阅读 2016-07-28 14:03:17
    Spring依赖注入详解 介绍:  所谓依赖注入就是指:在运行期间,有外部容器动态地将依赖对象注入到组件中 分为: 1.setter方法注入 2.使用构造器注入 3.使用Field注入(用于注解方式) 4.使用静态工厂的方法注入...
  • spring依赖注入原理详解

    千次阅读 2016-08-16 09:23:52
    spring依赖注入原理详解
  • Spring的核心 依赖注入 DI 切面编程 AOP spring要引入的jar包有: commons-logging-1.2 spring-beans-4.1.4 spring-context-4.1.4 ...Spring依赖注入的原理是:Spring是个bean容器,从XML里面读配置,通过
  • 本文目录依赖注入基于构造方法的依赖注入创建Spring工程创建dao创建ServiceSpring配置文件添加测试代码基于setter方法的依赖注入 依赖注入 Spring框架的核心功能之一就是通过依赖注入的方式来管理Bean之间的依赖关系...
  • Spring依赖注入:   基于构造函数的依赖注入 基于设值函数的依赖注入 注入内部beans 注入集合 自动装配: byName byType,一般我们都是用byType 构造函数 ...
  • http://outofmemory.cn/code-snippet/3670/spring-inject-by-annotation Spring依赖注入:注解注入总结
  • Spring依赖注入 依赖注入主要是对我们创建的JavaBean中的属性进行赋值。比如,下面我们创建两个类Person类(有getter()和setter()方法)和Student类: 1. 编写JavaBean Person类 Student类 ...
  • 一、再谈Spring依赖注入:  依赖注入大家应该都不陌生,在Spring 博客系类中队依赖注入以及Spring容器管理依赖都了一定的介绍,简单来说,A调用B,B调用C,Spring框架把这种组件之间的调用关系叫做依赖,也就是说A...
  • Spring 依赖注入(DI) 源码解析

    千次阅读 2020-03-10 17:49:18
    在分析Spring依赖注入的过程之前,建议您先了解:Spring IOC 源码解析,这样或许会让你的思路更加清晰。 1.依赖注入介绍         依赖注入,即 Spring 中的 DI(Dependency...
  • Spring 依赖注入:自动注入properties文件中的配置 在很多情况下我们需要在配置文件中配置一些属性,然后注入到bean中,Spring提供了org.springframework.beans.factory.config.PreferencesPlaceholderConfigurer类...
  • Spring依赖注入,property-ref注入内部bean 1.导入jar包 2.写JavaBean 3.注入依赖 4.测试类
  • Spring依赖注入与控制反转 IoC
  • Spring框架的核心功能之一就是通过依赖注入的方式来管理Bean之间的依赖关系。 我们之前没有 Spring 的时候,都是通过 new 的方式实例化类,调用方法、属性啥的,但是现在有了 Spring 之后,我们可以通过 Spring 的...
  • Spring依赖注入的三种方式

    千次阅读 2015-03-11 11:08:25
    Spring依赖注入(DI)的三种方式,分别为:1. 接口注入 2. Setter方法注入 3. 构造方法注入下面介绍一下这三种依赖注入在Spring中是怎么样实现的。首先我们需要以下几个类:接口 Logic.java接口实现类 ...
  • 什么是Spring依赖注入

    千次阅读 2019-11-14 11:53:21
    什么是Spring依赖注入?有什么好处 依赖注入:是指程序运行过程中,如果需要创建一个对象,无须再代码中new创建,而是依赖外部的注入。 spring依赖注入对调用者和被调用者几乎没有任何要求,完全支持对pojo之间...
  • Spring依赖注入实现简单工厂模式

    千次阅读 2018-08-01 17:39:37
    Spring依赖注入实现简单工厂模式 背景 想写一个简单的策略模式+简单工厂模式的抽奖算法. 下面写的是一个利用传入的抽奖类型调用不同的增加抽奖次数的方法. 首先写一个抽象工厂AbstractLotteryType类: ...
  • Spring依赖注入的接口为null

    千次阅读 2017-04-13 10:23:24
    昨天碰到一个问题,Spring依赖注入接口总是null。 因为之前使用的时候都是可以的,所以我就各种尝试,我的类进行实现接口,进行组件定义等等都不行。今早重新看看依赖注入的定义,组件之间依赖关系由容器在运行期...
  • 这类语句在SSH的配置中会大量存在,因为Spring所谓的核心机制就是Spring依赖注入IOC。下面举一个例子说明这个问题: 先贴上目录结构: 在Eclipse中新建一个Java工程,不是JavaWeb,在这个Java配置好Spring...
  • Spring 依赖注入 Spring框架中,依赖注入(DI)的设计模式是用来定义对象彼此间的依赖。它主要有两种类型: Setter方法注入 构造器注入 自动注入 在Spring中,支持 5 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 37,754
精华内容 15,101
关键字:

spring依赖注入

spring 订阅