Spring之对象依赖关系

最新推荐文章于 2023-02-14 17:03:11 发布
最新推荐文章于 2023-02-14 17:03:11 发布
阅读量420 收藏
点赞数
分类专栏： Spring 文章标签： Spring Spring之对象属性赋值
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bighuan/article/details/71184714
版权

一,概述

Spring中给对象的属性赋值的几种方式:

1)通过构造函数(在上一篇博客Spring之IOC容器有介绍)

2)通过set方法给属性注入值

3)p名称空间

4)自动装配(了解)

5)注解(方便,但比较难维护)

二,准备工作

1)UserDao.java

package com.bighuan.c_property;

public class UserDao {

	public void save(){
		System.out.println("DB:保存用户");
	}
}

2)UserService.java

package com.bighuan.c_property;

public class UserService {

	private UserDao userDao;//=new UserDao();
	
	//IOC:对象的创建交给spring的外部容器创建
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}
	public void save(){
		userDao.save();
	}
}

3)User.java

package com.bighuan.c_property;

public class User {

	public User(){
		System.out.println("------创建user对象[无参构造器]----");
	}
	
	public User(int id, String name) {
		System.out.println("------创建user对象[有参构造器]----");
		this.id = id;
		this.name = name;
	}

	private int id;
	private String name;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	public void init_user(){
		System.out.println("在创建user对象后初始化");
	}
	
	public void destroy_user(){
		System.out.println("IOC容器销毁,user对象回收");
	}

	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + "]";
	}
	
	
}

4)UserAction.java

package com.bighuan.c_property;

public class UserAction {

	// service:springIOC容器注入
	private UserService userService;

	public void setUserService(UserService userService) {
		this.userService = userService;
	}

	public String execute() {
		userService.save();
		return null;
	}
}

三,Spring之对象属性赋值

1)通过set方法注入值

<?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"
	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">

	<!-- IOC容器的配置:要创建的所有对象都在这里配置 -->

	<!-- *****对象属性赋值 ***** -->

	<!-- 1,通过构造函数 -->
	<bean id="user1" class="com.bighuan.c_property.User">
		<constructor-arg value="11" index="0" type="int"></constructor-arg>
		<constructor-arg value="bighuan" index="1"
			type="java.lang.String"></constructor-arg>
	</bean>

	<!-- 2,通过set方法给属性注入值 -->
	<bean id="user" class="com.bighuan.c_property.User">
		<property name="id" value="18"></property>
		<property name="name" value="张国荣"></property>
	</bean>

	<!-- 案例:dao/service/action -->

	<!-- dao instance -->
	<bean id="userDao" class="com.bighuan.c_property.UserDao">
	</bean>

	<!-- service instance -->
	<bean id="userService" class="com.bighuan.c_property.UserService">
		<property name="userDao" ref="userDao"></property>
	</bean>
	
	<!-- action instance -->
	<bean id="userAction" class="com.bighuan.c_property.UserAction">
		<property name="userService" ref="userService"></property>
	</bean>
	
</beans>
执行测试代码: 

@Test
	public void testExecAction() throws Exception {
		ApplicationContext ac1 = new ClassPathXmlApplicationContext(
				"com/bighuan/c_property/bean.xml");
		UserAction action=(UserAction) ac1.getBean("userAction");
		action.execute();
	}
控制台输出: DB:保存用户,所以通过set方法注入值成功了,最终执行了UserDao的save方法.
此外,还可以通过内部bean的方式注入值: 

<!-- ********内部bean******** -->
	<bean id="userAction2" class="com.bighuan.c_property.UserAction">
		<property name="userService">
			<bean class="com.bighuan.c_property.UserService">
				<property name="userDao">
					<bean class="com.bighuan.c_property.UserDao"></bean>
				</property>
			</bean>
		</property>
	</bean>
通过测试,最终结果是一样的.

2)p名称空间注入属性值

<?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"
	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">

	<!-- IOC容器的配置:要创建的所有对象都在这里配置 -->

	<!-- *****对象属性赋值 ***** -->
	<!-- 
		给对象的属性注入值 
		# p 名称空间给对象的属性注入值
		(一般spring3.0以上版本才支持)
	-->
	<bean id="userDao" class="com.bighuan.c_property.UserDao"></bean>
	
	<bean id="userService" class="com.bighuan.c_property.UserService" p:userDao-ref="userDao"></bean>
	
	<bean id="userAction" class="com.bighuan.c_property.UserAction" p:userService-ref="userService"></bean>

	<!-- p名称空间优化后 -->
	<bean id="user" class="com.bighuan.c_property.User" p:name="rose"></bean>
	
</beans>
执行测试代码: 

@Test
	public void testExecAction() throws Exception {
		UserAction action=(UserAction) ac.getBean("userAction");
		action.execute();
		
		System.out.println(ac.getBean("user"));
	}
输出结果: 

------创建user对象[无参构造器]----
DB:保存用户
User [id=0, name=rose]
这种方式给属性赋值相较于上面那种方式更为简单了;使用的时候,一定要声明才能用! 
xmlns:p="http://www.springframework.org/schema/p"

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" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	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"
	default-autowire="byName">

	<!-- IOC容器的配置:要创建的所有对象都在这里配置 -->

	<!-- *****自动装配***** -->
	<!-- 自动装配可以定义到全局: default-autowire="byName",这样就可以不用每个节点都定义:autowire="byName" -->

	<bean id="userDao111" class="com.bighuan.d_auto.UserDao"></bean>

	<!-- <bean id="userService" class="com.bighuan.d_auto.UserService"></bean> -->
	<!--<bean id="userAction" class="com.bighuan.d_auto.UserAction"></bean> -->

	<bean id="userService222" class="com.bighuan.d_auto.UserService"
		autowire="byType"></bean>

	<!-- 根据"名称"自动装配 ,UserAction注入的属性,会去IOC容器中自动查找与属性同名的对象 -->
	<bean id="userAction" class="com.bighuan.d_auto.UserAction"
		autowire="byType"></bean>

	<!-- 如果根据类型自动装配： 必须确保IOC容器中只有一个该类型的对象 -->
	<!-- 报错： 因为上面已经有一个该类型的对象，且使用了根据类型自动装配 
	<bean id="userService_test" class="com.bighuan.d_auto.UserService"
		autowire="byType"></bean>-->

</beans>
说明都在代码注释里了.

4)注解

a)必须要引入context名称空间:xmlns:context="http://www.springframework.org/schema/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" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	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">

	<!-- 开启注解扫描 -->
	<context:component-scan base-package="com.bighuan.e_anno"></context:component-scan>
</beans>
b)UserDao.java 

package com.bighuan.e_anno;

import org.springframework.stereotype.Component;

//把当前对象加入IOC容器
@Component("userDao")//<bean id="userDao" class="com.bighuan.d_auto.UserDao"></bean>
public class UserDao {

	public void save(){
		System.out.println("DB:保存用户");
	}
}
c)UserService.java 

package com.bighuan.e_anno;

import javax.annotation.Resource;

import org.springframework.stereotype.Component;
//将UserService加入IOC容器
@Component("userService")
public class UserService {

	@Resource(name = "userDao")
	private UserDao userDao;// =new UserDao();

	// IOC:对象的创建交给spring的外部容器创建
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}

	public void save() {
		userDao.save();
	}
}
d)UserAction.java 

package com.bighuan.e_anno;

import javax.annotation.Resource;

import org.springframework.stereotype.Component;
@Component("userAction")//将userAction加入IOC容器
public class UserAction {

	// service:springIOC容器注入
	@Resource(name="userService")
	private UserService userService;

	public void setUserService(UserService userService) {
		this.userService = userService;
	}

	public String execute() {
		userService.save();
		return null;
	}
}
e)测试 

@Test
	public void testExecAction() throws Exception {
		UserAction action=(UserAction) ac.getBean("userAction");
		action.execute();
	}
结果与上面那两种方式一样.

其实注解还可以更简单.

UserDao.java

package com.bighuan.e_anno2;

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;

//把当前对象加入IOC容器
//<bean id="userDao" class="com.bighuan.d_auto.UserDao"></bean>
//加入IOC容器的UserDao对象的引用名称,默认与类名一样,只是首字母小写
//@Component //不能区分哪一个层次的数据
@Repository//表示这是持久层
public class UserDao {

	public void save(){
		System.out.println("DB:保存用户");
	}
}

UserService.java 

package com.bighuan.e_anno2;

import javax.annotation.Resource;

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
//将UserService加入IOC容器
//@Component

@Service
// 代表业务逻辑层的组件
public class UserService {

	// @Resource(name="userDao")//根据名称查找
	@Resource
	private UserDao userDao11;// 去容器中找UserDao类型的变量,找到后就赋值,与名字无关

	public void save() {
		userDao11.save();
	}
}

UserAction.java 

package com.bighuan.e_anno2;

import javax.annotation.Resource;

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
//@Component
@Controller //控制层的组件
public class UserAction {

    // service:springIOC容器注入
    @Resource
    private UserService userService;

    public String execute() {
        userService.save();
        return null;
    }
}
创建对象以及处理对象依赖关系，相关的注解：
@Component   指定把一个对象加入IOC容器
@Repository   作用同@Component； 在持久层使用
@Service      作用同@Component； 在业务逻辑层使用
@Controller    作用同@Component； 在控制层使用
@Resource     属性注入
总结：
使用注解，可以简化配置，且可以把对象加入IOC容器,及处理依赖关系(DI).
注解可以和XML配置一起使用.

四,总结

不想写了,好烦!

bighuan
关注
专栏目录
Spring框架jar包之间的依赖关系(详细图解)
06-27
Spring框架jar包依赖关系图解, PowerDesigner源文件, 图片 以及 对应的各个模块关系
对象依赖关系
weixin_30715523的博客
03-11 168
Spring中，如何给对象的属性赋值? 【DI, 依赖注入】 1) 通过构造函数 2) 通过set方法给属性注入值 3) p名称空间 4)自动装配(了解) 5) 注解 # 注解 注解方式可以简化spring的IOC容器的配置! 使用注解步骤： 1）先引入context名称空间 xmlns:context="htt...
【Spring】对象依赖关系
Evan_QB的博客
10-19 543
Spring中，如何给对象的属性赋值?  【DI, 依赖注入】 1) 通过构造函数 2) 通过set方法给属性注入值 3) p名称空间 4)自动装配(了解) 5) 注解 通过构造方法注入值 set方法注入值 set方法进行关系注入 使用内部bean注入值
05-对象的依赖关系-依赖注入
anhldd的博客
12-10 488
一、set方法注入 value：表示值类型的注入 ref：表示对象类型的注入 pojo public class Person { private String name; private Integer age; private Car car; } public class Car { private String name; private String color; } bean配置 ...
Spring中的依赖关系(DI)
Keep learing, and stay fast
10-11 932
Spring 以“依赖注入”的方式实现了“控制反转"的效果，以便符合软件工程中“依赖倒置”原则。
Spring+Spring依赖jar包+Spring日志
07-21
首先，Spring的核心是依赖注入（Dependency Injection，DI），它允许开发者在运行时将对象组合在一起，而不是在编译时硬编码它们的依赖关系。通过使用XML配置文件或注解，我们可以声明性地定义对象及其依赖关系，...
spring framework体系结构及模块jar依赖关系详解
08-25
Spring Framework 体系结构及模块 JAR 依赖关系详解 Spring Framework 是一个广泛使用的 Java 企业级应用程序开发框架，提供了一个完整的生态系统来构建企业级应用程序。 Spring Framework 由多个模块组成，每个...
Spring实战之使用@Resource配置依赖操作示例
08-25
其中，Chinese 对象依赖于 Axe 对象，我们使用 @Resource 注解来标注这个依赖关系。在 Chinese 对象的 setAxe() 方法中，我们使用 @Resource 注解来注入依赖的 Axe 对象。 测试类 在测试类中，我们使用 Spring 的 ...
spring依赖包
12-16
通过容器管理对象的生命周期和依赖关系，使得代码更加解耦，便于测试和维护。 2. **Spring Beans**: 它定义了如何配置和管理对象，这些对象被称为"bean"。XML配置文件或者Java配置类可以用来定义bean及其依赖关系。...
Spring——基础面试题
吴声子夜歌的博客
09-17 1501
1. 什么是Spring？ Spring 是个 java 企业级应用的开源开发框架。Spring 主要用来开发 Java 应用，但是有些扩展是针对构建 J2EE 平台的 web 应用。Spring 框架目标是简化 Java 企业级应用开发，并通过 POJO 为基础的编程模型促进 良好的编程习惯。 2. 使用Spring框架的好处是什么？ 轻量：Spring是轻量的，基本的版本大约2MB 控制反转：Spring通过控制反转实现了松散耦合，对象们给出它们的依赖，而不是创建或者查找依赖的对象们 面向切面编程（A
C++对象与对象的关系
weixin_59179454的博客
11-11 899
在概念上，它们都是对象实例间的一种静态关系，都是在类的抽象层次上的定义，并且最终都可以通过对象的属性来体现。但它们差别是，聚合关系所涉及的两个类型的对象，在现实世界中的含义有明显的has - a (有一个)的语义，能够区分哪个是整体，哪个是部分，而关联所涉及的对象之间没有这种语义，即分不出整体和部分的关系。程序类之间的“依赖”关系主要体现出的是一种使用关系，对于两个相对独立的对象， 当一个对象负 责构造另一个对象的实例，或者当一个对象依赖于另一个对象所提供的服务时，这两个对象之间主要体现为依赖关系。
对象之间的关系
最新发布
m0_54355172的博客
02-14 2156
Java对象间的6种关系：依赖、关联、组合、聚合、继承、实现
OOP13-对象之间的依赖关系和组装
理论联系实际
03-28 475
对象之间的依赖关系和组装 对象之间的知道关系 类之间的构成关系 一个类作为另一类的组成部分。 类之间的方法参数依赖 一个类作为另一个类的方法的参数或者返回值的类型。 对象之间的组装关系 一个对象是另一个对象的组成部分 由构造函数初始化组成部分（对象）。 整体和部分的对象相互依赖， 或者整体对象可以在后来去除对部分对象的依赖。 对象之间松散组成关系 一个对象由另一个对象的setter函数或者其它函数...
Spring各个jar包之间的依赖关系
javadamn的博客
04-10 259
https://blog.csdn.net/a909301740/article/details/78332991
spring对象依赖
a459211842的博客
02-11 266
原文地址：http://blog.csdn.net/Evan_QB/article/details/78290589Spring中，如何给对象的属性赋值?  【DI, 依赖注入】1) 通过构造函数2) 通过set方法给属性注入值3) p名称空间4)自动装配(了解)5) 注解通过构造方法注入值[html] view plain copy print?&lt;span style="font-size...
Spring整理系列(02)——spring依赖注入，组装对象之间的依赖关系
javaloveiphone的专栏
08-06 2805
上篇文章整理了spring容器注册bean的实现方式，本文将整理spring注入bean的实现方式，多数文章按照setter和构造器注入的纬度来介绍，本文将按照如何采用setter和构造器的纬度来整理，即xml配置注入、xml配置自动装配、注解自动装配三种方式，希望说的不啰嗦。一、xml配置注入，手动装配，提供setter方法或者constructor构造函数1、需提供setter方法方式：spri
java依赖对象_对象创建的依赖
weixin_32799203的博客
02-26 530
对象创建的依赖关于依赖的哲学，最典型的违反莫过于对象创建的依赖。自面向对象的大旗树立以来，对于对象创建话题的讨论就从未停止。不管是工厂模式还是依赖注入，其核心的思想就只有一个：如何更好地解耦对象创建的依赖关系。所以，在这一部分，我们就以对象创建为主线，来认识对于依赖关系的设计轨迹，分别论述一般的对象创建、工厂方式创建和依赖注入创建三种方式的实现、特点和区别。1．典型的违反一般而言，以new关键字进...
Spring依赖
qq_44960253的博客
06-24 2074
Spring 依赖 什么是 Spring 依赖？ 与继承类似，依赖 也是描述 bean 和 bean 之间的一种关系。 配置依赖之后，被依赖的 bean 一定先创建，再创建 依赖的 bean。eg：A 依赖于 B。则 B 一定先创建。 Spring 对象创建顺序 当你在 Java 类中创建了 ApplicationContext 类时，就会创建 相关联的 xml 文件中的 Spring 对象。并且 Spring 对象的创建顺序是根据 xml 文件中 bean 的顺序来创建的。 但是现在问题是，在 xml
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值