浅谈spring ioc的注入方式及注入不同的数据类型
关于Spring-IoC的简单使用参考：
spring ioc的简单实例及bean的作用域属性解析
1、通过set方法注入不同数据类型
测试类代码(set方式注入的属性一定要加set方法)
/**通过set方法注入示例*/
public class IoC_By_Set {
/**注入Integer类型参数*/
private Integer id;
/**注入String类型参数*/
private String name;
/**注入实体Bean*/
private User user;
/**注入数组*/
private Object[] array;
/**注入List集合*/
private List<Object> list;
/**注入Set集合*/
private Set<Object> set;
/**注入Map键值对*/
private Map<Object, Object> map;
/**注入properties类型*/
private Properties properties;
/**注入空字符串*/
private String emptyValue;
/**注入null值*/
private String nullValue = "";
/**检测注入的属性是否全部正确*/
public Boolean checkAttr() {
if(id == null) {
return false;
} else {
System.out.println("id:" + id);
}
System.out.println("--------------------------");
if(name == null) {
return false;
} else {
System.out.println("name:" + name);
}
System.out.println("--------------------------");
if(user == null) {
return false;
} else {
System.out.println("Bean:" + user.getId() + "|" +
user.getUserName() + "|" + user.getPassWord());
}
System.out.println("--------------------------");
if(array == null) {
return false;
} else {
System.out.println("array:");
for (Object object : array) {
System.out.println(object.toString());
}
}
System.out.println("--------------------------");
if(list == null) {
return false;
} else {
System.out.println("list:");
for (Object object : list) {
System.out.println(object.toString());
}
}
System.out.println("--------------------------");
if(set == null) {
return false;
} else {
System.out.println("set:");
for (Object object : set) {
System.out.println(object.toString());
}
}
System.out.println("--------------------------");
if(map == null) {
return false;
} else {
Set<Entry<Object, Object>> set = map.entrySet();
System.out.println("map:");
for (Entry<Object, Object> entry : set) {
System.out.println(entry.getKey() + "|" + entry.getValue());
}
}
System.out.println("--------------------------");
if(properties == null) {
return false;
} else {
Set<Entry<Object, Object>> set = properties.entrySet();
System.out.println("properties:");
for (Entry<Object, Object> entry : set) {
System.out.println(entry.getKey() + "|" + entry.getValue());
}
}
System.out.println("--------------------------");
if(!"".equals(emptyValue))
return false;
System.out.println("--------------------------");
if(!(null == nullValue))
return false;
System.out.println("--------------------------");
System.out.println("全部正确！！！");
return true;
}
public void setId(Integer id) {
this.id = id;
}
public void setName(String name) {
this.name = name;
}
public void setUser(User user) {
this.user = user;
}
public void setArray(Object[] array) {
this.array = array;
}
public void setList(List<Object> list) {
this.list = list;
}
public void setSet(Set<Object> set) {
this.set = set;
}
public void setMap(Map<Object, Object> map) {
this.map = map;
}
public void setProperties(Properties properties) {
this.properties = properties;
}
public void setEmptyValue(String emptyValue) {
this.emptyValue = emptyValue;
}
public void setNullValue(String nullValue) {
this.nullValue = nullValue;
}
}
applicationContext.xml配置
<!-- set方式注入 -->
<bean id="ioC_By_Set" class="com.bc.ioc.demo01.IoC_By_Set">
<!-- 注入id属性 -->
<property name="id" value="1"/>
<!-- 使用<![CDATA[]]>标记处理XML特 殊字符 -->
<property name="name">
<!-- 也可以使用P&G -->
<value><![CDATA[P&G]]></value>
</property>
<!-- 定义内部Bean注入 -->
<property name="user">
<bean class="com.bc.pojo.User">
<property name="id" value="1"/>
<property name="userName" value="内部Bean"/>
<property name="passWord" value="233"/>
</bean>
</property>
<!-- 注入数组类型 -->
<property name="array">
<array>
<!-- 定义数组元素 -->
<value>array01</value>
<value>array02</value>
<value>array03</value>
</array>
</property>
<!-- 注入List类型 -->
<property name="list">
<list>
<!-- 定义list中元素 -->
<value>list01</value>
<value>list02</value>
<value>list03</value>
</list>
</property>
<!-- 注入Set类型 -->
<property name="set">
<set>
<!-- 定义set中元素 -->
<value>set01</value>
<value>set02</value>
<value>set03</value>
</set>
</property>
<!-- 注入Map类型 -->
<property name="map">
<map>
<!-- 定义map中的键值对 -->
<entry>
<key>
<value>mapKey01</value>
</key>
<value>mapValue01</value>
</entry>
<entry>
<key>
<value>mapKey02</value>
</key>
<value>mapValue02</value>
</entry>
</map>
</property>
<!-- 注入properties类型 -->
<property name="properties">
<props>
<!-- 定义properties中的键值对 -->
<prop key="propKey1">propValue1</prop>
<prop key="propKey2">propValue2</prop>
</props>
</property>
<!-- 注入空字符串 -->
<property name="emptyValue">
<value></value>
</property>
<!-- 注入null值 -->
<property name="nullValue">
<null/>
</property>
</bean>
测试代码
public class IoC_Test {
private ApplicationContext ctx;
@Before
public void load() {
//读取applicationContext.xml配置文件
ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
}
@Test
public void SetTest() {
IoC_By_Set ioc = (IoC_By_Set) ctx.getBean("ioC_By_Set");
ioc.checkAttr();
}
}
控制台结果：
id:1 -------------------------- name:P&G -------------------------- Bean:1|内部Bean|233 -------------------------- array: array01 array02 array03 -------------------------- list: list01 list02 list03 -------------------------- set: set01 set02 set03 -------------------------- map: mapKey01|mapValue01 mapKey02|mapValue02 -------------------------- properties: propKey2|propValue2 propKey1|propValue1 -------------------------- -------------------------- -------------------------- 全部正确！！！
2、通过构造方法注入各种类型属性
注意：使用JDK1.8版本请将spring相关jar包升级到4.x版本以上,否则不兼容构造方法注入
测试类代码
/** 通过构造方法注入示例 */
public class IoC_By_Constructor {
private Integer id;
private String name;
private User user;
private List<Object> list;
public IoC_By_Constructor() {
}
public IoC_By_Constructor(Integer id, String name, User user,
List<Object> list) {
this.id = id;
this.name = name;
this.user = user;
this.list = list;
}
/**检查是否注入成功*/
public Boolean checkAttr() {
if(id == null) {
return false;
} else {
System.out.println("id:" + id);
}
System.out.println("----------------------------");
if(name == null) {
return false;
} else {
System.out.println("name:" + name);
}
System.out.println("----------------------------");
if(user == null) {
return false;
} else {
System.out.println("user:" + user.getId() + "|" +
user.getUserName() + "|" + user.getPassWord());
}
System.out.println("----------------------------");
if(list == null) {
return false;
} else {
System.out.println("list:");
for (Object object : list) {
System.out.println(object.toString());
}
}
System.out.println("----------------------------");
System.out.println("全部正确！！！");
return true;
}
}
applicationContext.xml配置
<!-- 构造方法注入 演示几种类型-->
<bean id="ioC_By_Constructor" class="com.bc.ioc.demo02.IoC_By_Constructor">
<!-- 注入Integer属性,可以选择使用index指定参数位置,也可以选择使用type指定参数类型 -->
<constructor-arg index="0" value="1" type="java.lang.Integer"/>
<!-- 注入字符串 -->
<constructor-arg value="P&G"/>
<!-- 注入对象 -->
<constructor-arg>
<!-- 内建对象 -->
<bean class="com.bc.pojo.User">
<constructor-arg value="1"/>
<constructor-arg value="构造内部Bean"/>
<constructor-arg value="666"/>
</bean>
</constructor-arg>
<!-- 注入集合 -->
<constructor-arg>
<list>
<value>list01</value>
<value>list02</value>
<value>list03</value>
</list>
</constructor-arg>
</bean>
测试代码：
public class IoC_Test {
private ApplicationContext ctx;
@Before
public void load() {
//读取applicationContext.xml配置文件
ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
}
@Test
public void constructorTest() {
IoC_By_Constructor ioc = (IoC_By_Constructor) ctx.getBean("ioC_By_Constructor");
ioc.checkAttr();
}
}
控制台结果：
id:1 ---------------------------- name:P&G ---------------------------- user:1|构造内部Bean|666 ---------------------------- list: list01 list02 list03 ---------------------------- 全部正确！！！
3、自动注入(自动装配)
自动装配虽然能节省一些代码但是不推荐使用
测试类代码：
/**自动装配注入*/
public class IoC_By_Auto {
private User user;
/**检查是否注入成功*/
public Boolean checkAttr() {
if(user == null) {
return false;
} else {
System.out.println("user:" + user.getId() + "|" +
user.getUserName() + "|" + user.getPassWord());
}
System.out.println("正确！！！");
return true;
}
/**自动装配的属性需要设置set方法*/
public void setUser(User user) {
this.user = user;
}
}
applicationContext.xml配置
<!-- 被自动装配获取的bean -->
<bean id="user" class="com.bc.pojo.User">
<property name="id" value="1"/>
<property name="userName" value="自动装配"/>
<property name="passWord" value="233"/>
</bean>
<!-- 自动装配的bean
autowire:byName 根据类的属性名查找与之命名相同的id的bean进行装配
byType 根据类的属性类型查找唯一一个匹配类型的bean,如果有多个bean匹配则抛出异常
constructor 根据类的构造方法参数类型匹配对应的bean
no 默认,表示不使用自动装配
default：由上级标签<beans>的default-autowire属性确定 -->
<bean id="ioC_By_Auto" class="com.bc.ioc.demo03.IoC_By_Auto" autowire="byName"></bean>
测试代码
public class IoC_Test {
private ApplicationContext ctx;
@Before
public void load() {
//读取applicationContext.xml配置文件
ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
}
@Test
public void AutoTest() {
IoC_By_Auto ioc = (IoC_By_Auto) ctx.getBean("ioC_By_Auto");
ioc.checkAttr();
}
}
控制台结果
user:1|自动装配|233 正确！！！
以上使用的是byName模式,其他模式配置代码已经注明,不做测试。
4、使用P命名空间注入属性
测试类代码
/**使用P命名空间注入*/
public class IoC_By_P {
private Integer id;
private String name;
private User user;
/**检查是否注入成功*/
public Boolean checkAttr() {
if(id == null) {
return false;
} else {
System.out.println("id:" + id);
}
System.out.println("----------------------------");
if(name == null) {
return false;
} else {
System.out.println("name:" + name);
}
System.out.println("----------------------------");
if(user == null) {
return false;
} else {
System.out.println("user:" + user.getId() + "|" +
user.getUserName() + "|" + user.getPassWord());
}
System.out.println("----------------------------");
System.out.println("全部正确！！！");
return true;
}
//使用P命名空间注入属性需要设置set方法
public void setId(Integer id) {
this.id = id;
}
public void setName(String name) {
this.name = name;
}
public void setUser(User user) {
this.user = user;
}
}
applicationContext.xml配置
<!-- 使用P命名空间注入各种类型属性 -->
<bean id="user2" class="com.bc.pojo.User">
<property name="id" value="1"/>
<property name="userName" value="P"/>
<property name="passWord" value="233"/>
</bean>
<bean id="ioC_By_P" class="com.bc.ioc.demo04.IoC_By_P" p:id="1"
p:name="命名空间" p:user-ref="user2"></bean>
测试代码
public class IoC_Test {
private ApplicationContext ctx;
@Before
public void load() {
//读取applicationContext.xml配置文件
ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
}
@Test
public void PTest() {
IoC_By_P ioc = (IoC_By_P) ctx.getBean("ioC_By_P");
ioc.checkAttr();
}
}
控制台结果
id:1 ---------------------------- name:命名空间 ---------------------------- user:1|P|233 ---------------------------- 全部正确！！！
5、使用注解方式注入
Spring在3.0以后，提供了基于Annotation（注解）的注入。
1.@Autowired-对成员变量、方法和构造函数进行标注，来完成自动装配的工作，不推荐使用
2.@Qualifier-配合@Autowired来解决装配多个同类型的bean
3.@Resource-JSR-250标准注解，作用相当于@Autowired，只不过@Autowired按byType自动注入，而@Resource默认按byName自动注入
4.@PostConstruct-在方法上加上注解@PostConstruct，这个方法就会在Bean初始化之后被Spring容器执行
5.@PreDestroy-在方法上加上注解@PreDestroy，这个方法就会在Bean初始化之后被Spring容器执行
6.@Component-只需要在对应的类上加上一个@Component注解，就将该类定义为一个Bean，不推荐使用，推荐使用更加细化的三种：@Repository、@Service、@Controller
@Repository存储层Bean
@Service业务层Bean
@Controller展示层Bean
7.@Scope-定义Bean的作用范围
首先配置applicationContext.xml开启注解
<!-- 扫描包中注解标注的类 --> <context:component-scan base-package="com.bc.ioc.demo05"/>
实体Bean加注解
@Repository
public class User {
private Integer id = 1;
private String userName = "注解注入";
private String passWord = "233";
public User() {
super();
}
public User(Integer id, String userName, String passWord) {
super();
this.id = id;
this.userName = userName;
this.passWord = passWord;
}
public Integer getId() {
return id;
}
public String getUserName() {
return userName;
}
public String getPassWord() {
return passWord;
}
public void setId(Integer id) {
this.id = id;
}
public void setUserName(String userName) {
this.userName = userName;
}
public void setPassWord(String passWord) {
this.passWord = passWord;
}
}
测试类代码加注解
/**使用注解注入属性*/
@Service("ioC_By_Annotation")
public class IoC_By_Annotation {
@Resource
private User user;
public void setUser(User user) {
this.user = user;
}
/**检查是否注入成功*/
public Boolean checkAttr() {
if(user == null) {
return false;
} else {
System.out.println("user:" + user.getId() + "|" +
user.getUserName() + "|" + user.getPassWord());
}
System.out.println("正确！！！");
return true;
}
}
测试代码
public class IoC_Test {
private ApplicationContext ctx;
@Before
public void load() {
//读取applicationContext.xml配置文件
ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
}
@Test
public void annotationTest() {
IoC_By_Annotation ioc = (IoC_By_Annotation) ctx.getBean("ioC_By_Annotation");
ioc.checkAttr();
}
}
控制台输出
经测试使用注解注入如果applicationContext.xml配置有其他注入方式会报错,也会导致其他注入方式异常。
user:1|注解注入|233 正确！！！
6、通过配置静态工厂方法Bean注入
静态工厂代码
/**静态工厂*/
public class StaticFactory {
public static Integer getId() {
return 1;
}
public static String getName() {
return "静态工厂";
}
public static User getUser() {
return new User(1, "工厂User", "666");
}
}
测试类代码
/** 通过静态工厂方式注入 */
public class IoC_By_StaticFactory {
private Integer id;
private String name;
private User user;
/** 检查是否注入成功 */
public Boolean checkAttr() {
if (id == null) {
return false;
} else {
System.out.println("id:" + id);
}
System.out.println("----------------------------");
if (name == null) {
return false;
} else {
System.out.println("name:" + name);
}
System.out.println("----------------------------");
if (user == null) {
return false;
} else {
System.out.println("user:" + user.getId() + "|"
+ user.getUserName() + "|" + user.getPassWord());
}
System.out.println("----------------------------");
System.out.println("全部正确！！！");
return true;
}
/**需要为需要注入的属性设置set方法*/
public void setId(Integer id) {
this.id = id;
}
public void setName(String name) {
this.name = name;
}
public void setUser(User user) {
this.user = user;
}
}
applicationContext.xml配置
<!-- 配置静态工厂方法Bean 其实就是将工厂方法返回的数值配置成Bean -->
<bean id="factory_id" class="com.bc.ioc.demo06.StaticFactory" factory-method="getId"/>
<bean id="factory_name" class="com.bc.ioc.demo06.StaticFactory" factory-method="getName"/>
<bean id="factory_user" class="com.bc.ioc.demo06.StaticFactory" factory-method="getUser"/>
<!-- 注入对应的静态工厂方法Bean -->
<bean id="ioC_By_StaticFactory" class="com.bc.ioc.demo06.IoC_By_StaticFactory">
<property name="id" ref="factory_id"/>
<property name="name" ref="factory_name"/>
<property name="user" ref="factory_user"/>
</bean>
测试代码
public class IoC_Test {
private ApplicationContext ctx;
@Before
public void load() {
//读取applicationContext.xml配置文件
ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
}
@Test
public void staticFactoryTest() {
IoC_By_StaticFactory ioc = (IoC_By_StaticFactory) ctx.getBean("ioC_By_StaticFactory");
ioc.checkAttr();
}
}
控制台输出结果
id:1 ---------------------------- name:静态工厂 ---------------------------- user:1|工厂User|666 ---------------------------- 全部正确！！！
7、通过实例工厂方法注入
与静态工厂区别在于实例工厂不是静态的,需要先new 一个实例工厂对象,才可以配置其方法,而new 的这个对象也由spring来管理
工厂代码
/**实例工厂*/
public class Factory {
public Integer getId() {
return 1;
}
public String getName() {
return "实例工厂";
}
public User getUser() {
return new User(1, "实例工厂User", "233");
}
}
测试类代码
/**实例工厂注入*/
public class IoC_By_Factory {
private Integer id;
private String name;
private User user;
/** 检查是否注入成功 */
public Boolean checkAttr() {
if (id == null) {
return false;
} else {
System.out.println("id:" + id);
}
System.out.println("----------------------------");
if (name == null) {
return false;
} else {
System.out.println("name:" + name);
}
System.out.println("----------------------------");
if (user == null) {
return false;
} else {
System.out.println("user:" + user.getId() + "|"
+ user.getUserName() + "|" + user.getPassWord());
}
System.out.println("----------------------------");
System.out.println("全部正确！！！");
return true;
}
/**需要为需要注入的属性设置set方法*/
public void setId(Integer id) {
this.id = id;
}
public void setName(String name) {
this.name = name;
}
public void setUser(User user) {
this.user = user;
}
}
applicationContext.xml配置
<!-- 配置实例工厂Bean -->
<bean id="factory" class="com.bc.ioc.demo07.Factory"/>
<!-- 配置实例工厂方法Bean -->
<bean id="f_id" factory-bean="factory" factory-method="getId"/>
<bean id="f_name" factory-bean="factory" factory-method="getName"/>
<bean id="f_user" factory-bean="factory" factory-method="getUser"/>
<!-- 注入对应的实例工厂方法Bean -->
<bean id="ioC_By_Factory" class="com.bc.ioc.demo07.IoC_By_Factory">
<property name="id" ref="f_id"/>
<property name="name" ref="f_name"/>
<property name="user" ref="f_user"/>
</bean>
测试类代码
public class IoC_Test {
private ApplicationContext ctx;
@Before
public void load() {
//读取applicationContext.xml配置文件
ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
}
@Test
public void factoryTest() {
IoC_By_Factory ioc = (IoC_By_Factory) ctx.getBean("ioC_By_Factory");
ioc.checkAttr();
}
}
控制台输出
id:1 ---------------------------- name:实例工厂 ---------------------------- user:1|实例工厂User|233 ---------------------------- 全部正确！！！
总结
以上就是本文关于浅谈spring ioc的注入方式及注入不同的数据类型的全部内容，希望对大家有所帮助。感兴趣的朋友可以继续参阅本站其他相关专题，如有不足之处，欢迎留言指出。感谢朋友们对本站的支持！
您可能感兴趣的文章:
- 详谈Spring对IOC的理解(推荐篇)
- spring的IoC和DI详解
- Spring的Ioc模拟实现详细介绍
- Spring中IoC优点与缺点解析
- 简单理解Spring之IOC和AOP及代码示例
- Spring IOC原理详解
- 简单实现Spring的IOC原理详解
- Spring的IOC代码解析
相关推荐
-
Spring中IoC优点与缺点解析
本文为大家分享了Spring中IoC优点与缺点,供大家参考,具体内容如下 1. 优点 我们知道,在Java基本教程中有一个定律告诉我们:所有的对象都必须创建:或者说:使用对象之前必须创建,但是现在我们可以不必一定遵循这个定律了,我们可以从Ioc容器中直接获得一个对象然后直接使用,无需事先创建它们. 这种变革,就如同我们无需考虑对象销毁一样:因为Java的垃圾回收机制帮助我们实现了对象销毁:现在又无需考虑对象创建,对象的创建和销毁都无需考虑了,这给编程带来的影响是巨大的. 我们从一个简单例子开始,
-
详谈Spring对IOC的理解(推荐篇)
一.IOC控制反转和DI依赖注入 1.控制反转,字面可以理解为:主动权的转移,原来一个应用程序内的对象是类通过new去主动创建并实例化的,对对像创建的主动权在程序代码中.程序不仅要管理业务逻辑也要管理对的象创建和依赖关系.这是很累的,也跟软件工程 "低耦合高内聚" 的概念不十分符合. 有了spring的ioc容器之后,对象的实例化和依赖关系管理都由IOC容器进行统一管理,主体类只要依赖ioc容器就够了,需要啥,容器会给他注入进去,也就是只要声明对象不用再主动去new,ioc容器帮忙把相
-
Spring的Ioc模拟实现详细介绍
简单来说就是当自己需要一个对象的时候不需要自己手动去new一个,而是由其他容器来帮你提供:Spring里面就是IOC容器. 例如: 在Spring里面经常需要在Service这个装配一个Dao,一般是使用@Autowired注解:类似如下 public Class ServiceImpl{ @Autowired Dao dao; public void getData(){ dao.getData(); } 在这里未初始化Dao直接使用是会报出空指针异常的,那么在Spring里面的做法就是通过反
-
Spring IOC原理详解
最近,买了本Spring入门书:springInAction.大致浏览了下感觉还不错.就是入门了点.Manning的书还是不错的,我虽然不像哪些只看Manning书的人那样专注于Manning,但怀着崇敬的心情和激情通览了一遍.又一次接受了IOC.DI.AOP等Spring核心概念.先就IOC和DI谈一点我的看法. IOC(DI):其实这个Spring架构核心的概念没有这么复杂,更不像有些书上描述的那样晦涩.java程序员都知道:java程序中的每个业务逻辑至少需要两个或以上的对象来协作完成,通
-
简单实现Spring的IOC原理详解
控制反转(InversionofControl,缩写为IoC) 简单来说就是当自己需要一个对象的时候不需要自己手动去new一个,而是由其他容器来帮你提供:Spring里面就是IOC容器. 例如: 在Spring里面经常需要在Service这个装配一个Dao,一般是使用@Autowired注解:类似如下 public Class ServiceImpl{ @Autowired Dao dao; public void getData(){ dao.getData(); } 在这里未初始化Dao直接
-
Spring的IOC代码解析
IOC通常就是我们所说的控制反转,它也是属于java中的重点,在面试的时候常常会被问到. 控制反转(Inversion of Control,英文缩写为IoC)把创建对象的权利交给框架,是框架的重要特征,并非面向对象编程的专用术语.它包括依赖注入(Dependency Injection,简称DI)和依赖查找(Dependency Lookup). IOC使得程序获取对象的方式发生了改变,由开始的new一个对象转变为第三方框架的创建和注入.第三方框架一般是通过配置指定具体注入哪一个实现,从而降低
-
简单理解Spring之IOC和AOP及代码示例
Spring是一个开源框架,主要实现两件事,IOC(控制反转)和AOP(面向切面编程). IOC 控制反转,也可以称为依赖倒置. 所谓依赖,从程序的角度看,就是比如A要调用B的方法,那么A就依赖于B,反正A要用到B,则A依赖于B.所谓倒置,你必须理解如果不倒置,会怎么着,因为A必须要有B,才可以调用B,如果不倒置,意思就是A主动获取B的实例:Bb=newB(),这就是最简单的获取B实例的方法(当然还有各种设计模式可以帮助你去获得B的实例,比如工厂.Locator等等),然后你就可以调用b对象了.
-
spring的IoC和DI详解
这里先来简单介绍下IoC和DI的区别: IOC:翻译过来是控制反转,将对象的创建权由Spring管理,HelloService不需要自己去创建,Spring可以帮你创建. DI:依赖注入,在我们创建对象的过程中,把对象依赖的属性注入到我们的类中. 我们现在编写的类是没有其它的属性的,如果你学过UML这种设计的话,面向对象中对象中的几种关系 简单来书,IoC更像是一种思想,DI是一种行为. 另一种说法是,ioc是目的,di是手段.ioc是指让生成类的方式由传统方式(new)反过来,既程序员不调用n
-
浅谈spring ioc的注入方式及注入不同的数据类型
关于Spring-IoC的简单使用参考: spring ioc的简单实例及bean的作用域属性解析 1.通过set方法注入不同数据类型 测试类代码(set方式注入的属性一定要加set方法) /**通过set方法注入示例*/ public class IoC_By_Set { /**注入Integer类型参数*/ private Integer id; /**注入String类型参数*/ private String name; /**注入实体Bean*/ private User user; /
-
浅谈Spring IoC容器的依赖注入原理
本文介绍了浅谈Spring IoC容器的依赖注入原理,分享给大家,具体如下: IoC容器初始化的过程,主要完成的工作是在IoC容器中建立 BeanDefinition 数据映射,并没有看到IoC容器对Bean依赖关系进行注入, 假设当前IoC容器已经载入用户定义的Bean信息,依赖注入主要发生在两个阶段 正常情况下,由用户第一次向IoC容器索要Bean时触发 但我们可以在 BeanDefinition 信息中通过控制 lazy-init 属性来让容器完成对Bean的预实例化,即在初始化的过程中就
-
浅谈Spring Context加载方式
Spring 加载方式 对于可执行文件方式,我们一般的加载Spring 配置的方式是 ClassPathXmlApplicationContext public static void main(String[] args) { ClassPathXmlApplicationContext xmlApplicationContext = new ClassPathXmlApplicationContext("classpath:spring-context.xml"); DemoSer
-
浅谈spring DI 依赖注入方式和区别
目录 spring DI 3种DI注解的区别 1 @Autowired 2 @Inject 3 @Resource 3种注入方式的区别 1 field注入 2 构造器注入 3 setter注入 构造器注入的好处 1 依赖不可变 2 依赖不为空 3 完全初始化状态 4 避免循环依赖 5 总结 spring DI Spring框架对Java开发的重要性不言而喻,其核心特性就是IOC(Inversion of Control, 控制反转)和AOP,平时使用最多的就是其中的IOC,我们通过将组件交由Sp
-
浅谈Spring的两种事务定义方式
一.声明式 这种方法不需要对原有的业务做任何修改,通过在XML文件中定义需要拦截方法的匹配即可完成配置,要求是,业务处理中的方法的命名要有规律,比如setXxx,xxxUpdate等等.详细配置如下: <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="
-
spring IOC中三种依赖注入方式
一.Spring IOC(依赖注入的三种方式): 1.Setter方法注入. 2.构造方法注入. 使用构造方法,注入bean值. 关键代码: public UserServiceImpl(UserDao dao) { this.dao=dao; } <bean id="service" class="service.impl.UserServiceImpl"> <constructor-arg><ref bean="dao&q
-
浅谈spring中scope作用域
今天研究了一下scope的作用域.默认是单例模式,即scope="singleton".另外scope还有prototype.request.session.global session作用域.scope="prototype"多例.再配置bean的作用域时,它的头文件形式如下: 如何使用spring的作用域: <bean id="role" class="spring.chapter2.maryGame.Role" s
-
浅谈Spring的两种配置容器
Spring提供了两种容器类型 SpringIOC容器是一个IOC Service Provider.提供了两种容器类型:BeanFactory和ApplicationContext.Spring的IOC容器是一个提供IOC支持的轻量级容器.除了基本的ioc支持,它作为轻量级容器还提供了IOC之外的支持. BeanFactory BeanFactory是基础类型IOC容器.顾名思义,就是生产Bean的工厂.能够提供完整的IOC服务.没有特殊指定的话,其默认采用延迟初始化策略.只有当客户端对象需要
-
浅谈spring中的default-lazy-init参数和lazy-init
在spring的配置中的根节点上有个 default-lazy-init="true"配置: 1.spring的default-lazy-init参数 此参数表示延时加载,即在项目启动时不会实例化注解的bean,除非启动项目时需要用到,未实例化的注解对象在程序实际访问调用时才注入调用 spring在启动的时候,default-lazy-init参数默认为false,会默认加载整个对象实例图,从初始化ACTION配置.到 service配置到dao配置.乃至到数据库连接.事务等等.这样
-
浅谈spring 常用注解
我们不妨先将spring常用的注解按照功能进行分类 1 .将普通类加入容器形成Bean的注解 日常开发中主要使用到的定义Bean的注解包括(XML方式配置bean暂不讨论): @Component.@Repository.@Service.@Controller.@Bean 其中@Component.@Repository.@Service.@Controller实质上属于同一类注解,用法相同,功能相同,区别在于标识组件的类型.当一个组件代表数据访问层(Dao)时,你可以给它加上@Reposit