Spring IOC（XML和注解）

最新推荐文章于 2022-10-26 23:31:36 发布
最新推荐文章于 2022-10-26 23:31:36 发布
阅读量511 收藏 1
点赞数 2
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yzr_java/article/details/64905108
版权

      一：依赖注入 

      通过第一个Spring程序之后，创建对象的工作会交给Spring来完成，只需要在配置文件上配置相关的<bean>节点，通过Spring容器就可以根据配置创建对象。

       回顾上一个spring配置文件：

        <bean name="UserDao" class="yzr.dao.UserDao" ></bean>
	<bean name="UserService" class="yzr.service.UserService" >
		<property name="userDao" ref="UserDao"></property>
	</bean>
	<bean name="UserAction" class="yzr.action.UserAction" >
		<property name="userService" ref="UserService"></property>
	</bean>
      这种是通过属性方式的依赖注入，在<bean>节点内包含<property>节点，指定相应的依赖关系。在这种情况下，在Service中需要声明一个关于UserDao的set方法，就像这样： 

package yzr.service;

import yzr.dao.UserDao;

public class UserService {
	private UserDao userDao=null;
	public void setUserDao(UserDao userdao){
		userDao=userdao;
	}
	public void run(){
		userDao.run();
		System.out.println("Service执行Run");
	}
}
注意的地方是，<property name="userDao" ref="UserDao"></property>中name的值为userDao，与Service类中的属性变量userDao必须一致，注意大小写。

     除了上面这种通过属性依赖注入的方式，还有另外一种通过构造函数注入依赖，使用<constructor-arg>节点。 

        <bean name="UserDao" class="yzr.dao.UserDao" ></bean>
	<!-- 
	<bean name="UserService" class="yzr.service.UserService" >
		<property name="userDao" ref="UserDao"></property>
	</bean>
	-->
	<bean name="UserService" class="yzr.service.UserService" >
		<constructor-arg ref="UserDao"></constructor-arg>
	</bean>
	<bean name="UserAction" class="yzr.action.UserAction" >
		<property name="userService" ref="UserService"></property>
	</bean>
      通过构造函数注入的话，Service需要提供一个带依赖类型的构造函数，比如这样： 

package yzr.service;

import yzr.dao.UserDao;

public class UserService {
	private UserDao userDao=null;
	/*
	public void setUserDao(UserDao userdao){
		userDao=userdao;
	}
	*/
	public void run(){
		userDao.run();
		System.out.println("Service执行Run");
	}
	
	public UserService(){
		
	}
        public UserService(UserDao userDao){
    	       this.userDao=userDao;
	}
}

      通过上面两个例子可以往被创建对象注入值(或者对象)，此外，假若当需要注入的依赖为集合或者map类型时，spring也提供了相应的节点配置，下面使用属性注入方式说明：

      1.注入List集合：

      1）将String类型值注入集合中用value节点

      <bean name="UserAction" class="yzr.action.UserAction" >
		<property name="userService" ref="UserService"></property>
		<property name="stringList">
                    <list>
                        <value>YZR</value>
                    </list>
                 </property>
	</bean>
      相应的Action中声明一个stringList属性变量： 

        private List stringList=null;
	public void setStringList(List actionList) {
		this.stringList = actionList;
	}
      2）将对象类型注入集合中，使用bean节点 

       <property name="beanList">
                    <list>
                    	<bean id="Userbean" class="yzr.entity.UserBean">
	  	               <property name="name" value="YZR"></property>
	                </bean>
                    </list>
        </property>
     
      相应的Action中声明一个beanList属性变量： 

        private List beanList=null;
	public void setBeanList(List beanList) {
		this.beanList = beanList;
	}
      3）使用ref注入已有的bean 
 <bean name="UserAction" class="yzr.action.UserAction" >
		
        <property name="beanList">
                    <list>
                    	<ref bean="Userbean"/>
                    	
                    </list>
        </property>
</bean>
<bean id="Userbean" class="yzr.entity.UserBean">
     <property name="name" value="YZR"></property>
</bean>

    2.注入Map键值对：

    同理 与List，下面三种方式就写在一起表示：

        <property name="maps">
            <map>
                <entry key="StringKey" value="1" />
                <entry key="BeanKey" value-ref="Userbean" />
                <entry key="BeanKey2">
                    <bean id="Userbean" class="yzr.entity.UserBean">
	  	        <property name="name" value="YZR"></property>
	            </bean>
                </entry>
            </map>
        </property>
    3.注入prop属性文件的键值对：

    propertise属性文件的内容只能是文本类型的键值对，所以在prop节点内写上文本即可。

       <property name="pros">
            <props>
                <prop key="StringKey">StringValue</prop>
            </props>
        </property>
      二 P命名空间

    spring IOC容器在创建对象的时候，很多场景需要注入依赖，在使用属性方式注入时，编写property节点会很常用，为了简化配置文件关于property的写法，spring提供了P名称空间：   

xmlns:p="http://www.springframework.org/schema/p"
在编写bean节点的时候，可以使用 p:属性变量=值      
        <!--String类型注入-->
        <bean id="user" class="yzr.entity.UserBean" p:name="StringValue"></bean>
        <!--Bean对象注入-->
	<bean id="user" class="yzr.entity.UserBean" p:myBean-ref="BeanId"></bean>
      三  spring注解

     使用注解的方式来简化使用配置文件方式创建对象的过程：

           @Repository 在持久层使用     （dao）
           @Service    在业务逻辑层使用 （service）
           @Controller 在控制层使用     （action）

           @Component  把对象加入IOC容器，都可以使用这个注解 （通用）
           @Resource   注入属性值: 从容器中找指定名称的对象，如果没有指定名称，用修饰的成员变量名称！

     Dao:

package yzr.dao;

import org.springframework.stereotype.Repository;

@Repository
public class UserDao {
	public void run(){
		System.out.println("UserDao执行Run;");
	}
}
     Service: 

package yzr.service;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;

import yzr.dao.UserDao;
@Service
public class UserService {
	@Resource
	private UserDao userDao=null;
	/*
	public void setUserDao(UserDao userdao){
		userDao=userdao;
	}
	*/
	public void run(){
		userDao.run();
		System.out.println("Service执行Run");
	}
	
	public UserService(){
		
	}
}
      Action: 
        
package yzr.action;

import java.util.List;

import javax.annotation.Resource;

import org.springframework.stereotype.Controller;

import yzr.service.UserService;
@Controller
public class UserAction {
	@Resource
	private UserService userService=null;
	
	
	public String execute() throws Exception{
		userService.run();
		System.out.println("UserAction执行execute");
		//System.out.println(stringList);
		//System.out.println(beanList);
		return "success";
	}
}
applicationContext.xml配置文件： 

<?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:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
    	 http://www.springframework.org/schema/beans/spring-beans.xsd
     	 http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
     	 http://www.springframework.org/schema/tx/spring-tx.xsd">
     	 
    <context:component-scan base-package="yzr"></context:component-scan>	 
	
	
	
</beans>
测试： 

package yzr.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.Resource;

import yzr.action.UserAction;

public class app {
	String path="ApplicationContext.xml";
	@Test
	public void test() throws Exception{
		ClassPathXmlApplicationContext ac=new ClassPathXmlApplicationContext(path);
		System.out.println("加载配置文件完成");
		
		//UserAction action=(UserAction) ac.getBean("UserAction");
		//action.execute();
		
		UserAction action =null;
		action=ac.getBean(UserAction.class);
		action.execute();
	}
}


注意：当使用xml配置和使用注解两种方式一起使用的时候，如果当spring IOC容器在创建对象的时候匹配到两个或以上的时候会报错。

比如：在已经使用了注解的方式的前提下，然后又在配置文件中加上对UserAction的bean：

<?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:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
    	 http://www.springframework.org/schema/beans/spring-beans.xsd
     	 http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
     	 http://www.springframework.org/schema/tx/spring-tx.xsd">
     	 
    <context:component-scan base-package="yzr"></context:component-scan>	 
    <bean name="UserAction" class="yzr.action.UserAction" ></bean>
</beans>     

package yzr.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.Resource;

import yzr.action.UserAction;

public class app {
	String path="ApplicationContext.xml";
	@Test
	public void test() throws Exception{
		ClassPathXmlApplicationContext ac=new ClassPathXmlApplicationContext(path);
		System.out.println("加载配置文件完成");
		
		//UserAction action=(UserAction) ac.getBean("UserAction");
		//action.execute();
		
		UserAction action =null;
		action=ac.getBean(UserAction.class);
		action.execute();
	}
}

当getBean(UserAction.class)时会报错，报错信息为：

org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type [yzr.action.UserAction] is defined: expected single matching bean but found 2: userAction,UserAction

at org.springframework.beans.factory.support.DefaultListableBeanFactory.getBean(DefaultListableBeanFactory.java:289)
at org.springframework.context.support.AbstractApplicationContext.getBean(AbstractApplicationContext.java:1125)
at yzr.test.app.test(app.java:21)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at java.lang.reflect.Method.invoke(Method.java:597)
at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:44)
at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)
at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:41)
at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20)
at org.junit.runners.BlockJUnit4ClassRunner.runNotIgnored(BlockJUnit4ClassRunner.java:79)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:71)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:49)
at org.junit.runners.ParentRunner$3.run(ParentRunner.java:193)
at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:52)
at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:191)
at org.junit.runners.ParentRunner.access$000(ParentRunner.java:42)
at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:184)
at org.junit.runners.ParentRunner.run(ParentRunner.java:236)
at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:50)
at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)


因为使用注解的方式spring会自动创建一个UserAction对象，而在此时我们又手动在配置文件下又加上了一个UserAction类型的bean，所以使用getBean(UserAction.class)时spring容器创建对象时会找到两个UserAction。需要去掉其中一个才对。

所以，xml配置模式和注解在不冲突的条件下可以一起使用，但如果存在重复的时候spring会报错。





Yang_ZhiRan
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring2.5.6注解以及xml简单ioc入门示例
09-17
spring2.5.6注解以及xml两个简单ioc入门示例项目，导入项目可运行。 同时带有spring-framework-2.5.6-with-docs.zip包
学习spring ioc和aop
05-14
spring 核心功能演示项目 1. applicationContext xml方式和注解方式配置 2. pring bean循环依赖。 3. spring bean 启动顺序。 4. BeanDefinition编程式注入到容器。 5. spring aop 打印 6. spring 事务
Spring临时笔记 IOC：XML注入和注解注入
chennaji的博客
10-26 375
学习AOP过程中为了避免XML注入和注解注入两种方式创建对象，而写的临时笔记
Spring5学习笔记（五）IOC之xml自动装配、注解开发
Code皮皮虾的博客
08-05 446
文章目录1、引入外部属性文件2、Spring Bean基于xml装配bean(理解)3、Bean管理（基于注解方式）3.1、基于注解方式实现对象的创建3.1、开启组件扫描细节配置3.3、基于注解方式实现属性注入3.4、完全注解开发 1、引入外部属性文件 导入druid和mysql的jar包，我的mysql版本是8.x的，所以在驱动和url的值上跟5.x版的有所不同，具体值可以百度，很容易搜到。 1. 直接配置 <bean id="dataSource" class="com.alibaba.dru
IOC的两种实现——xml与注解(最全讲解与代码示例)
zsy_yyds的博客
10-18 529
IOC实现的万字讲解，满满的科技与狠活
Spring IOC基础 xml配置、注解配置
weixin_43838446的博客
05-14 201
依赖注入：Dependency Injection IOC的作用：降低程序间的耦合（依赖关系） 依赖关系的管理：交给spring管理 1.使用xml配置 1.1 ApplicationContext与BeanFactory 对两个文件：AccountServiceImpl、AccountDaoImpl进行注入 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/
Spring5之IOC操作Bean管理（基于xml和注解）
静水流深，沧笙踏歌
04-02 1784
前几天Spring框架曝出RCE 0day漏洞，可导致远程代码执行 (RCE)，使用JDK9及以上版本都有可能受到影响，还好博主用的是稳定的JDK8(JDK8真的是yyds)。本篇文章主要介绍一下spring核心之一的IOC/DI以及他们是如何通过XML和注解的方式实现Bean管理。 一、Spring的核心 Spring是轻量级的开源JavaEE框架，Spring主要用到的设计模式有工厂模式和代理模式，一般而言，工厂模式分为三类：简单工厂模式（Simple Factory）、工厂方法模式（F..
Spring5_IOC.pdf
12-30
一图详解IOC
Spring IOC之基于注解的容器配置.docx
06-19
Spring配置中注解比XML更好吗？基于注解的配置的介绍提出的问题是否这种途径比XML更好。简单来说就是视情况而定。 长一点的答案是每一种方法都有自己的长处也不足，而且这个通常取决于开发者决定哪一种策略更适合...
Spring-IoC 复习笔记.rar
10-23
《Spring-IoC 复习笔记》博客附件。 博客地址：https://blog.csdn.net/Supreme_Sir/article/details/109165058
Spring中IOC配置xml实现和IOC注解实现
简书的专栏
08-22 9489
1.什么是spring spring 是分层的JavaSE/EE轻量级应用开源框架，已控制反转IOC和面向切面编程AOP为核心，提供了展现层SpringMVC, 和持久层Srping JDBC以及事务管理等。 2.特点 方便解耦，简化开发 spring提供ioc容器，可以将对象之间的依赖关系交给spring控制，避免硬编码所造成的过度程序耦合。 AOP编程支持 通过s
Spring IOC 依赖注入的两种方式：XML和注解
楠人的博客-随风而过
02-19 5000
IoC，直观地讲，就是容器控制程序之间的关系，而非传统实现中，由程序代码直接操控。这也就是所谓“控制反转”的概念所在。控制权由应用代码中转到了外部容器，控制权的转移是所谓反转。IoC还有另外一个名字——“依赖注入（Dependency Injection）”。从名字上理解，所谓依赖注入，即组件之间的依赖关系由容器在运行期决定，形象地说，即由容器动态地将某种依赖关系注入到组件之中。 依赖注入的原理
Spring IOC 依赖注入的两种方式XML和注解
热门推荐
===小虫===
12-23 2万+
依赖注入的原理 依赖注入的方式---XML配置 依赖注入的方式---注解的方式 Spring 它的核心就是IOC和AOP。而IOC中实现Bean注入的实现方式之一就是DI（依赖注入）。 一 DI的原理 DI的基本原理：对象之间的依赖关系只会通过三种方式：构造函数参数，工厂方法的参数以及构造函数或工厂方法创建的对象属性设置。因此，容器的工作哦就是在创建Bean时注入所有的依赖关
Spring的IOC的xml和注解
zhang__liuchen的博客
03-29 267
XML：可以使用任何场景 优点：结构清晰，维护方便 注解：有些地方用不了，这个类不是自己提供的 优点：开发方便 ProductDao.java package com.cherry.spring.demo3; public class ProductDao { public void save() { System.out.println("ProductDao的save方法...
八 Spring的IOC的XML和注解的区别及其整合开发
weixin_30951743的博客
10-28 141
xml和注解的区别 xml和注解整合开发 注解：取消扫描配置开启注解配置 扫描：<context:component-scan base-package="" /> 是扫描类上的注解，比如@Component @Service等 当类上没有注解，可以不开启扫描，此时在没有扫描的情况下，使用属性注入的注解@Resource @AutoWired，此时应开启配置：<...
Spring学习（九）使用ioc注解方式配置bean
FFA(Frighting for Ambition!)
09-01 3760
context层 : 上下文环境/容器环境 applicationContext.xml1 ioc注解功能 注解 简化xml文件配置 如 hibernate 映射文件 ioc注解 简化 ioc容器的配置
SpringIOC应用之XML+注解模式
脑细胞:-D的博客
10-12 106
SpringIOC应用之XML+注解模式 xml+注解结合模式，xml⽂件依然存在，spring IOC容器的启动仍然从加载xml开始 那么哪些bean的定义写在xml中，哪些bean的定义使⽤注解 第三方jar中的bean定义在xml，⽐如德鲁伊数据库连接池 自己开发的bean定义使⽤注解 xml中标签与注解的对应（IOC） DI 依赖注⼊的注解实现方式（管理bean之间的依赖关系） @Autowired（推荐使⽤）:采取的策略为按照类型注⼊。 /*这样装配会去spring容器中找到类型为Account
使用注解来构造IoC容器
05-11 190
使用注解来构造IoC容器 用注解来向spring容器注册Bean。需要在applicationContext.xml中注册。 如：在base-package指明一个包 1 表明cn.gacl.Java包及其子包中，如果某个类的头上带有特定的注解【@Component/@Repository/@Service/@Controller】，就会将这个对象作为Bean注册进Spring容器。也可...
Spring IOC详细配置与使用
青元子的博客
06-08 1万+
前言：复习了解下Spring，顺便记录下这个过程以供日后翻阅。SpringIoc：    按照我个人的理解来说，SpringIOC（Inversion of Control）控制反转：指就是说原先在对象中要使用另一个对象就必须要显式的去创建另一个对象的实例，例如通过构造方法或者是调用工厂方法（工厂方法最终也是需要new，因为这是Java创建对象所必须的）来获得。而Spring提供了IOC容器来帮我...
spring ioc的spring.xml
最新发布
05-23
Spring IOC通过读取配置文件或注解来实现对象的创建、注入和管理。 在Spring中，IOC容器是通过XML文件进行配置的。这个XML文件一般被命名为spring.xml或applicationContext.xml。 下面是一个简单的spring.xml文件...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值