Spring2.5依赖注入方式(DI)

最新推荐文章于 2024-07-22 08:55:10 发布
最新推荐文章于 2024-07-22 08:55:10 发布
阅读量752 收藏
点赞数
分类专栏： Java/Spring 文章标签： spring autowired user encoding class setter

Spring2.5依赖注入的方式有三种：

  1. 通过setter方法注入；
  2. 通过构造方法注入；
  3. 通过注解进行注入；

第一种方式：通过setter方法注入

Java代码 复制代码  收藏代码
  1. package com.test;   
  2.   
  3. public class UserServiceImplement implements IUserService   
  4.   
  5. {   
  6.     private IUserDao user;   
  7.   
  8.     public IUserDao getUser() {   
  9.         return user;   
  10.     }   
  11.   
  12.     public void setUser(IUserDao user) {   
  13.         this.user = user;   
  14.     }   
  15.   
  16.     public void saveUser() {   
  17.         user.addUser();   
  18.     }   
  19. }  
package com.test;

public class UserServiceImplement implements IUserService

{
	private IUserDao user;

	public IUserDao getUser() {
		return user;
	}

	public void setUser(IUserDao user) {
		this.user = user;
	}

	public void saveUser() {
		user.addUser();
	}
}

 

Xml代码 复制代码  收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:lang="http://www.springframework.org/schema/lang"  
  4.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang-2.0.xsd">  
  5.     <bean id="userdao" class="com.test.UserDaoImplement"></bean>  
  6.     <bean id="userservice" class="com.test.UserServiceImplement">  
  7.         <property name="user" ref="userdao"></property>  
  8.     </bean>  
  9. </beans>  

 

 注意这种方法还可以把XML改成以下方式：

 

Xml代码 复制代码  收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:lang="http://www.springframework.org/schema/lang"  
  4.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang-2.0.xsd">  
  5.     <bean id="userservice" class="com.test.UserServiceImplement"> <!-- <property name="user" ref="userdao"></property>-->  
  6.         <property name="user">  
  7.             <bean class="com.test.UserDaoImplement"></bean>  
  8.         </property>  
  9.     </bean>  
  10. </beans>  

 

这两者的区别在于，第二种方式只会注入到当前这个Bean实例中，而不能再注入到其它的Bean中，第一种方式被注入的Bean可以注入到多个Bean当中，这可能会有一些线程安全的问题，因此在最好指定被注入的Bean的作用域。

 

另外通过setter方式注入，对应的注入依赖属性，必须要有setter方法。

 

 

 

测试代码：

Java代码 复制代码  收藏代码
  1. package com.test;   
  2.   
  3. import org.springframework.context.ApplicationContext;   
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;   
  5.   
  6. public class Test {   
  7.     public static void main(String[] args) {   
  8.         ApplicationContext ctx = new ClassPathXmlApplicationContext(   
  9.                 "com/test/bean.xml");   
  10.         IUserService us = (IUserService) ctx.getBean("userservice");   
  11.         us.saveUser();   
  12.     }   
  13. }  
package com.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
	public static void main(String[] args) {
		ApplicationContext ctx = new ClassPathXmlApplicationContext(
				"com/test/bean.xml");
		IUserService us = (IUserService) ctx.getBean("userservice");
		us.saveUser();
	}
}

 

第二种方式：通过构造方法进行注入

Java代码 复制代码  收藏代码
  1. package com.test;   
  2.   
  3. public class UserServiceImplement implements IUserService {   
  4.     private IUserDao user;   
  5.     int age;   
  6.   
  7.     public UserServiceImplement(IUserDao user, int age) {   
  8.         this.user = user;   
  9.         this.age = age;   
  10.     }   
  11.   
  12.     public void saveUser() {   
  13.         user.addUser();   
  14.         System.out.println(this.age);   
  15.     }   
  16. }  
package com.test;

public class UserServiceImplement implements IUserService {
	private IUserDao user;
	int age;

	public UserServiceImplement(IUserDao user, int age) {
		this.user = user;
		this.age = age;
	}

	public void saveUser() {
		user.addUser();
		System.out.println(this.age);
	}
}

Xml代码 复制代码  收藏代码
  1. <beans xmlns="http://www.springframework.org/schema/beans"  
  2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:lang="http://www.springframework.org/schema/lang"  
  3.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang-2.0.xsd">  
  4.     <bean id="userdao" class="com.test.UserDaoImplement"></bean>  
  5.     <bean id="userservice" class="com.test.UserServiceImplement">  
  6.         <constructor-arg index="0" type="com.test.IUserDao"  
  7.             ref="userdao"></constructor-arg>  
  8.         <constructor-arg index="1" value="24"></constructor-arg>  
  9.     </bean>  
  10. </beans>  

 

 

 

 

注意

  • <construcotr-arg>标签中的index属性如果构造方法只有一个参数的时候可以不指定，它的下标从0开始，表示构造方法参数的索引，如果有构造方法有多个参数必须指定索引。除此之外还有一个type属性，这个属性用来指定被注入的参数的参数类型，一定要跟构造方法中的参数类型一致，如果是一个接口，那么也不允许传它的实现类，这是一个可选属性；
  • 如果构造函数的的参数类型是基本数据类型，那么就不用ref属性了，而用value属性设置它的值，而且这些数据类型会自动打包和解包；
  • 同样要注意bean的作用域问题。

 测试代码同上......

 

第三种方式：通过java注解进行注入

 

使用这种方式进行注入可以用两个标注：

  • @Resource
  • @Autowired

两者的区别：1. @Resource标注是由JDK提供的，而@Autowired标注是由Spring提供的，因而@Autowired标注会与Spring紧密耦合，所以推荐使用@Resource标注；

                  2. @Resource默认是按照名称来装配注入的，当找不到与名称匹配的bean才会按照类型来装配注入；

                  3. @Autowired默认是按照类型装配注入的，如果想按照名称来转配注入，则需要结合@Qualifier一起使用；

                  4. @Resource和@Autowired都可以用来标注字段或者setter方法。

 

I.使用@Resource标注进行注入

Java代码 复制代码  收藏代码
  1. package com.test;   
  2.   
  3. import javax.annotation.Resource;   
  4.   
  5. public class UserServiceImplement implements IUserService {   
  6.   
  7.     @Resource  
  8.     private IUserDao user;   
  9.   
  10.     private IUserDao user1;   
  11.   
  12.     public IUserDao getUser1() {   
  13.         return user1;   
  14.     }   
  15.   
  16.     @Resource  
  17.     public void setUser1(IUserDao user1) {   
  18.         this.user1 = user1;   
  19.     }   
  20.   
  21.     public void saveUser() {   
  22.         user.addUser();   
  23.         System.out.println("user注入成功");   
  24.         user1.addUser();   
  25.         System.out.println("user1注入成功");   
  26.     }   
  27. }  
package com.test;

import javax.annotation.Resource;

public class UserServiceImplement implements IUserService {

	@Resource
	private IUserDao user;

	private IUserDao user1;

	public IUserDao getUser1() {
		return user1;
	}

	@Resource
	public void setUser1(IUserDao user1) {
		this.user1 = user1;
	}

	public void saveUser() {
		user.addUser();
		System.out.println("user注入成功");
		user1.addUser();
		System.out.println("user1注入成功");
	}
}

 

Xml代码 复制代码  收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
  4.     xsi:schemaLocation="http://www.springframework.org/schema/beans    
  5.            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd   
  6.            http://www.springframework.org/schema/context   
  7.            http://www.springframework.org/schema/context/spring-context-2.5.xsd">  
  8.     <context:annotation-config />  
  9.   
  10.     <bean id="user" class="com.test.UserDaoImplement"></bean>  
  11.     <bean id="user1" class="com.test.UserDaoImplement"></bean>  
  12.     <bean id="userservice" class="com.test.UserServiceImplement"></bean>  
  13. </beans>  

 

 测试类：

Java代码 复制代码  收藏代码
  1. package com.test;   
  2.   
  3. import org.springframework.context.ApplicationContext;   
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;   
  5.   
  6. public class Test {   
  7.   
  8.     public static void main(String[] args) {   
  9.         ApplicationContext ctx = new ClassPathXmlApplicationContext(   
  10.                 "com/test/bean.xml");   
  11.         IUserService us = (IUserService) ctx.getBean("userservice");   
  12.         us.saveUser();   
  13.     }   
  14. }  
package com.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

	public static void main(String[] args) {
		ApplicationContext ctx = new ClassPathXmlApplicationContext(
				"com/test/bean.xml");
		IUserService us = (IUserService) ctx.getBean("userservice");
		us.saveUser();
	}
}

 

II.使用@Autowired

 

Java代码 复制代码  收藏代码
  1. package com.test;   
  2.   
  3. import org.springframework.beans.factory.annotation.Autowired;   
  4.   
  5. public class UserServiceImplement implements IUserService {   
  6.   
  7.     @Autowired  
  8.     private IUserDao user;   
  9.   
  10.     public IUserDao getUser() {   
  11.         return user;   
  12.     }   
  13.   
  14.     public void setUser(IUserDao user) {   
  15.         this.user = user;   
  16.     }   
  17.   
  18.     public void saveUser() {   
  19.         user.addUser();   
  20.         System.out.println("user注入成功");   
  21.     }   
  22. }  
package com.test;

import org.springframework.beans.factory.annotation.Autowired;

public class UserServiceImplement implements IUserService {

	@Autowired
	private IUserDao user;

	public IUserDao getUser() {
		return user;
	}

	public void setUser(IUserDao user) {
		this.user = user;
	}

	public void saveUser() {
		user.addUser();
		System.out.println("user注入成功");
	}
}

 

Xml代码 复制代码  收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
  4.     xsi:schemaLocation="http://www.springframework.org/schema/beans    
  5.            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd   
  6.            http://www.springframework.org/schema/context   
  7.            http://www.springframework.org/schema/context/spring-context-2.5.xsd">  
  8.     <context:annotation-config />  
  9.   
  10.     <bean id="user" class="com.test.UserDaoImplement"></bean>  
  11.     <bean id="userservice" class="com.test.UserServiceImplement"></bean>  
  12. </beans>  

 测试类：

Java代码 复制代码  收藏代码
  1. package com.test;   
  2.   
  3. import org.springframework.context.ApplicationContext;   
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;   
  5.   
  6. public class Test {   
  7.   
  8.     public static void main(String[] args) {   
  9.         ApplicationContext ctx = new ClassPathXmlApplicationContext(   
  10.                 "com/test/bean.xml");   
  11.         IUserService us = (IUserService) ctx.getBean("userservice");   
  12.         us.saveUser();   
  13.     }   
  14. }  
package com.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

	public static void main(String[] args) {
		ApplicationContext ctx = new ClassPathXmlApplicationContext(
				"com/test/bean.xml");
		IUserService us = (IUserService) ctx.getBean("userservice");
		us.saveUser();
	}
}

 

 

thx: http://krcjwj.iteye.com/blog/400497
eyeooo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring 2.5依赖包
10-13
1. **依赖注入 (Dependency Injection, DI)**：Spring 2.5对依赖注入进行了优化，支持了基于注解的配置（@Autowired和@Qualifier），这使得开发者无需通过XML配置就能实现组件之间的依赖关系，提高了代码的可读性...
详析Spring中依赖注入的三种方式
09-01
在Spring框架中，依赖注入（Dependency Injection，简称DI）是一种重要的设计模式，它允许开发者将对象的创建和管理交由Spring容器处理，从而减少代码间的耦合，提高系统的可测试性和可维护性。本文将详细解析Spring...
Spring2.5教程：4、注入依赖
cheney521的专栏
12-25 855
注入依赖对象 基本类型对象注入(比如属性)： orderService" class="cn.itcast.service.OrderServiceBean">   arg index=“0” type=“java.lang.String” value=“xxx”/>//构造器注入   zhao/>//属性setter方法注入 注入其他bean： 方式一 orderDao" cl
干货丨 Spring框架实现依赖注入操作，步骤详解！
技术专家
08-03 780
Dependency Injection是spring框架核心 ioc 的具体实现。程序在编写时通过控制反转把对象的创建交给了spring，但是代码中不可能出现没有依赖的情况。 ioc 解耦只是降低他们的依赖关系但不会消除，坐等框架把持久层对象传入业务层而不用我们自己去获取。 **推荐打卡教程： Spring高级之注解驱动开发详解** Spring框架实现依赖注入 依赖注入作用是在使用Spring框架创建对象时，动态的将其所依赖的对象注入到Bean组件中，其实现方式通常有两种一种是属性setter方法注
springboot2.5版本依赖
weixin_58102380的博客
07-21 237
<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-dependencies --> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-dependencies</artifactId> &l
SpringBoot学习——所需依赖
Wang________的博客
04-09 252
SpringBoot项目实际上就是一个Maven的父模块 包含了很多依赖 SpringBoot整合JSP (由于效率低下 不推荐使用) <!--web依赖--> <dependency> <groupId>org.springframework.boot</groupId> ...
一个完整的springboot项目所需要导入的依赖合集（方便查找）
qq_56728342的博客
06-22 3万+
一、springboot启动类依赖： 二、springboot测试类依赖： 三、mybatis-plus依赖： 四、lombok依赖（用来简化对类的操作包括：set、get以及构造函数等，只需要 一个注解） 导入lombok依赖后还需要进行一步操作，下载lombok插件，方法：点击File—>Setting—>Plugins然后再搜索框搜索Lombok，安装插件即可。五、mysql连接所需要的依赖： 导入了mysql依赖后需要连接数据库，在application.yaml配置文件中配置连
spring四种依赖注入方式的详细介绍
08-31
Spring框架的依赖注入（Dependency Injection，DI）是其核心特性之一，它允许开发者将对象的创建和组装过程交由Spring容器来管理，从而降低代码之间的耦合度，提高可测试性和可维护性。本文将详细讲解Spring框架中的...
sping2.5依赖注入示例
03-13
在这个名为"spring2.5依赖注入示例"的小demo中，我们将探讨Spring框架如何实现DI，并通过实际的代码示例来理解这一核心特性。 首先，让我们定义什么是依赖注入。在软件设计中，当一个类A依赖于另一个类B时，我们说A...
Spring依赖注入检查.
03-25
Spring 2.5引入了基于注解的依赖注入，使得代码更简洁。使用`@Autowired`注解可以在字段、构造器或setter方法上自动装配依赖： ```java @Component public class MyClass { @Autowired private MyDependency ...
Spring2.5.6开发依赖包最全最好完整版
11-20
该txt文件中是spring2.5.6完整版开发依赖包的直接下载地址，迅雷中直接新建下载任务复制该地址就可快速下载。该依赖包中包含了所有Spring开发中用到的jar文件以及spring框架源码，和相关开发文档，api，示例等，欢迎下载学习。
SpringBoot常用依赖
weixin_45870173的博客
05-08 67
起步依赖 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.4.RELEASE</version> </parent> <dependency> <groupId&gt
spring2.5 所需jar包
ETHAN IN IT
02-29 626
spring2.5 需要使用到的jar包： aspectjrt.jar aspectjweaver.jar c3p0-0.9.1.2.jar cglib-nodep-2.1_3.jar common-annotations.jar(j2ee) commons-logging.jar jaxen-1.1.1.jar(JUnit Tes
Spring boot2基本依赖
热门推荐
长草颜团子
01-24 21万+
springboot基本依赖 <dependencies> <!--=================================================默认基础==============================================--> <dependency> &l...
springboot依赖包大全
小猿备忘录
11-20 3937
每次引用依赖包的时候都会想到能不能用的问题，这下给大家搞了一下，springboot官网文档中的依赖包，放心用吧。 Group ID Artifact ID Version antlr antlr 2.7.7 ch.qos.logback logback-access ...
Springboot2.5集成HttpClient依赖，封装HTTP请求类并配置连接池
我思故我在的博客空间
12-10 5159
先看需要引入的依赖： <!--Http服务器的访问功能--> <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpasyncclient</artifactId> </dependency> <!-- http通信 --> <dependency> <groupId>o
SpringBoot2版本起步依赖原理以及加载默认配置解析
mister_Wei的博客
09-27 2610
虽然Spring的组件代码是轻量级的，但它的配置却是重量级的。一开始，Spring用XML配置，而且是很多XML配 置。Spring 2.5引入了基于注解的组件扫描，这消除了大量针对应用程序自身组件的显式XML配置。Spring 3.0引入 了基于Java的配置，这是一种类型安全的可重构配置方式，可以代替XML。 所有这些配置都代表了开发时的损耗。因为在思考Spring特性配置和解决业务问题之间需...
SpringBoot2.5.0快速入门教程
传智燕青
05-29 3972
1 Spring Boot入门程序 1.1 Spring Boot是什么？ Spring Boot是一套可以快速创建Spring应用程序的框架，它要实现如下目标： 1、提供更快使用Spring的方案。 2、解决创建Spring应用程序过程使用XML配置的繁琐问题。 大量的XML配置使用整个工程的构建过程非常繁琐，Spring Boot则要解决这个问题。 3、提供一系列大型项目通用的非功能性功能（例如嵌入式服务器，安全性，指标，运行状况检查和外部化配置）。 4、解决复杂的jar包依赖的问题 通常我们需要手动在
Vue 3 和 SpringBoot 实现文件分片上传示例
最新发布
exlink2012的专栏
07-22 442
实现分片上传，并使用Spring Boot在后端保存文件。前端将文件分片并逐个上传到后端，后端接收到所有分片后再进行合并，最终保存为一个完整文件。
Spring 2.5 Autowired注解：简化IoC实例化
Spring 2.5版本引入了@Autowired注解，这是一个核心特性，使得依赖注入（Dependency Injection, DI）更加直观和高效。 @Autowired注解用于自动装配（Automatic Dependency Injection），当在方法或字段上使用该注解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值