Spring学习笔记(二)

续Spring 学习笔记(一)之后,对Spring框架XML的操作进行整理

1 什么是IOC(DI)

IOC = inversion of control   控制反转

DI   = dependency injection 依赖注入

2 个人理解IOC(DI)的好处和作用

本来自己在代码NEW的东西改为由Spring来管理,体现了控制方的转变。

在由Spring管理的时候,需要用户通过配置bean来实现bean与bean的关联,依赖/注入为配置的方式,

好处何作用---》只需要管理配置文件就可以对类的进行管理-->灵活,可阅读性强。

本次笔记中的Spring的常用配置说明目录

1 Spring的注入类型

2 简单的属性注入

3 scope属性

4 集合注入MAP,SET,LIST

5 自动装配 autowire

6 生命周期lazy-init  和初始毁灭方法的调用 init-method,destroy-method

3 Spring 的注入类型

a setter注入(笔记一里已经实现,不再累述)

b 构造方法注入(沿用笔记一里的文件进行修改)

UserServiceImpl 类(存在构造函数)

package com.serviceImpl;

import com.dao.UserDao;
import com.daoImpl.UserDaoImpl;
import com.entity.User; public class UserServiceImpl {
private UserDao userDao; UserServiceImpl(UserDao userDao){//构造函数
this.userDao = userDao;
} public void add(User user) {
userDao.save(user);
} public void modify(User user) {
userDao.update(user);
} public UserDao getUserDao() {
return userDao;
}
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
}

beans.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="userDaoImpl" class="com.daoImpl.UserDaoImpl">
</bean> <bean id="userDaoImpl2" class="com.daoImpl.UserDaoImpl2">
</bean> <bean id="userServiceImpl" class="com.serviceImpl.UserServiceImpl">
<constructor-arg><ref bean="userDaoImpl"/></constructor-arg> <!-- 构造函数的注入配置-->
</bean>
</beans>

执行UserServiceImplTest文件(无任何改动)

执行结果

testName-->testRemark  save --调用UserDaoImpl!

testName-->testRemark  update --调用UserDaoImpl!

总结,构造方法与setter方法注入实现起来差不多,只是调用的bean里面内部的标签不同而已

4 bean 标签里 使用Id和name的区别,这个不做研究了,查看了下文档,name只可以输入特殊字符"@#!@$!",没什么区别。

4 简单的属性注入

UserServiceImpl里面有个int类型的变量testInjectValue 未赋值

package com.serviceImpl;

import com.dao.UserDao;
import com.daoImpl.UserDaoImpl;
import com.entity.User; public class UserServiceImpl {
private UserDao userDao;
int testInjectValue;//简单属性注入的测试 UserServiceImpl(UserDao userDao){
this.userDao = userDao;
} public void add(User user) {
userDao.save(user);
System.out.println("testInjectValue = "+testInjectValue);
} public void modify(User user) {
userDao.update(user);
System.out.println("testInjectValue = "+testInjectValue);
} public UserDao getUserDao() {
return userDao;
}
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
} public int getTestInjectValue() {
return testInjectValue;
} public void setTestInjectValue(int testInjectValue) {
this.testInjectValue = testInjectValue;
} }

我们通过beans.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="userDaoImpl" class="com.daoImpl.UserDaoImpl">
</bean> <bean id="userDaoImpl2" class="com.daoImpl.UserDaoImpl2">
</bean> <bean id="userServiceImpl" class="com.serviceImpl.UserServiceImpl">
<constructor-arg><ref bean="userDaoImpl"/></constructor-arg>
<property name="testInjectValue" value="34"></property> <!--简单属性的注入-->
</bean>
</beans>

执行测试文件

执行结果

testName-->testRemark save --调用UserDaoImpl!
testInjectValue = 34

testName-->testRemark update --调用UserDaoImpl!
testInjectValue = 34

总结.与接口的setter注入差不多,只是接口对应的是 bean="beanName", 这里是value="value"

5 bean里面的scope属性的运用

1 scope=singleton

beans.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="userDaoImpl" class="com.daoImpl.UserDaoImpl">
</bean> <bean id="userDaoImpl2" class="com.daoImpl.UserDaoImpl2">
</bean> <bean id="userServiceImpl" class="com.serviceImpl.UserServiceImpl" scope="singleton"> <!-- 添加配置scope="singleton"-->
<constructor-arg><ref bean="userDaoImpl"/></constructor-arg>
</bean>
</beans>

2 scope=prototype

beans.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="userDaoImpl" class="com.daoImpl.UserDaoImpl">
</bean> <bean id="userDaoImpl2" class="com.daoImpl.UserDaoImpl2">
</bean> <bean id="userServiceImpl" class="com.serviceImpl.UserServiceImpl" scope="prototype"> <!-- 添加配置scope="prototype"-->
<constructor-arg><ref bean="userDaoImpl"/></constructor-arg>
</bean>
</beans>

3 分别配置scope=prototype/singleton和不配置scope 并执行UserServiceImplTest文件并查看结果

package com.serviceImpl.test;

import static org.junit.Assert.*;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; import com.entity.User;
import com.serviceImpl.UserServiceImpl; public class UserServiceImplTest {
User user; @Before
public void setUp() throws Exception {
user = new User();
user.setName("testName");
user.setRemark("testRemark");
} @Test
public void testAdd() {
ApplicationContext app = new ClassPathXmlApplicationContext("beans.xml");
UserServiceImpl UserServiceImpl = (UserServiceImpl)app.getBean("userServiceImpl");
UserServiceImpl UserServiceImpl2 = (UserServiceImpl)app.getBean("userServiceImpl");
System.out.println(UserServiceImpl==UserServiceImpl2);
// UserServiceImpl.add(user);//调用方法
} @Test
public void testModify() {
ApplicationContext app = new ClassPathXmlApplicationContext("beans.xml");
UserServiceImpl UserServiceImpl = (UserServiceImpl)app.getBean("userServiceImpl");
UserServiceImpl UserServiceImpl2 = (UserServiceImpl)app.getBean("userServiceImpl");
System.out.print(UserServiceImpl==UserServiceImpl2);
// UserServiceImpl.modify(user);
}
}

当scope=singleton时 执行结果为 true true

当scope=prototype时 执行结果为false false

当不配置scope时         执行结果为true true

总结 scope不做定义时,spring默认类的实现方式是为单例模式

只有scope=prototype时,spring会在每次调用时都去重新NEW一个新的类

6集合注入

UserServiceImpl

package com.serviceImpl;

import java.util.List;
import java.util.Map;
import java.util.Set; import com.dao.UserDao;
import com.daoImpl.UserDaoImpl;
import com.entity.User; public class UserServiceImpl {
private UserDao userDao; Map testMap;
Set testSet;
List testList; public void add(User user) {
userDao.save(user);
System.out.println(testMap.get("m"));
System.out.println(testSet.iterator());
System.out.println(testList.get(0));
} public UserDao getUserDao() {
return userDao;
} public void setUserDao(UserDao userDao) {
this.userDao = userDao;
} public Map getTestMap() {
return testMap;
} public void setTestMap(Map testMap) {
this.testMap = testMap;
} public Set getTestSet() {
return testSet;
} public void setTestSet(Set testSet) {
this.testSet = testSet;
} public List getTestList() {
return testList;
} public void setTestList(List testList) {
this.testList = testList;
}
}

beans.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="userDaoImpl" class="com.daoImpl.UserDaoImpl">
</bean> <bean id="userDaoImpl2" class="com.daoImpl.UserDaoImpl2">
</bean> <bean id="userServiceImpl" class="com.serviceImpl.UserServiceImpl">
<property name="userDao" ref="userDaoImpl"></property>
<property name="testList">
<list>
<value>inject list</value>
</list>
</property> <property name="testMap">
<map>
<entry key="m" value="inject map" />
</map>
</property>
<property name="testSet">
<set>
<value>inject set</value>
</set>
</property>
</bean>
</beans>

执行UserServiceImplTest文件

执行结果

testName-->testRemark save --调用UserDaoImpl!
inject map
java.util.LinkedHashMap$KeyIterator@435a3a
inject list

总结 

1 这个还是和之前的注入差不多,要用的时候看一眼说明书即可。

7  自动装配(不是很常用)

autowire="byName"(不在代码实现了,用byType抛砖引玉)

autowire="byType"(注意:spring如果找到一个以上的具有同类型的bean会报错,所以我这里注释了userDaoImpl的bean)

beans.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd"> <!-- <bean id="userDaoImpl" class="com.daoImpl.UserDaoImpl">-->
<!-- </bean>--> <bean id="userDaoImpl2" class="com.daoImpl.UserDaoImpl2">
</bean> <bean id="userServiceImpl" class="com.serviceImpl.UserServiceImpl" autowire="byType">
<!-- <property name="userDao" ref="userDaoImpl"></property>-->
</bean>
</beans>

执行UserServiceImplTest文件

执行结果

testName-->testRemark  save --调用UserDaoImpl2!

总结

1 这个功能点不是很重要,按类型的话很多bean可能会起冲突,如果按名字的话,又对名字有很高的匹配要求,所以不是很实用。

2 另外在头部配置 autowire 的默认值后,可以使用beans的属性:default-autowire (基于这个功能不是很实用,所以没去试过)。

8 生命周期(配置bean的初始策略)

lazy-init

当不配置lazy-init=true时 applicationcontext被NEW出来的时候,所有的bean都会被初始化。

当配置了,这个bean就不会被初始化,除非方法调用。(系统启动特别慢时,可以考虑lazy-init =true 不然没什么太大意义

 init-method destroy-methd 方法的使用

beans.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="userDaoImpl" class="com.daoImpl.UserDaoImpl">
</bean> <bean id="userDaoImpl2" class="com.daoImpl.UserDaoImpl2">
</bean> <bean id="userServiceImpl" class="com.serviceImpl.UserServiceImpl" init-method="init" destroy-method="destroy" lazy-init="true">
<property name="userDao" ref="userDaoImpl"></property>
</bean>
</beans>

UserServiceImpl

package com.serviceImpl;

import com.dao.UserDao;
import com.daoImpl.UserDaoImpl;
import com.entity.User; public class UserServiceImpl {
private UserDao userDao; public void add(User user) {
userDao.save(user);
} public void init(){//初始方法
System.out.println("init");
} public void destroy(){//销毁方法
System.out.println("destory");
} public UserDao getUserDao() {
return userDao;
} public void setUserDao(UserDao userDao) {
this.userDao = userDao;
} }

UserServiceImplTest

package com.serviceImpl.test;

import static org.junit.Assert.*;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; import com.entity.User;
import com.serviceImpl.UserServiceImpl; public class UserServiceImplTest {
User user; @Before
public void setUp() throws Exception {
user = new User();
user.setName("testName");
user.setRemark("testRemark");
} @Test
public void testAdd() {
ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("beans.xml");
UserServiceImpl UserServiceImpl = (UserServiceImpl)app.getBean("userServiceImpl");
UserServiceImpl UserServiceImpl1 = (UserServiceImpl)app.getBean("userServiceImpl");
UserServiceImpl.add(user);//调用方法
app.destroy();//在WEB应用里会自动调用,这里直接手动调用了。
} }

执行UserServiceImplTest文件

执行结果

init
testName-->testRemark save --调用UserDaoImpl!

destory

总结

 init-method destroy-methd 方法的使用需要注意别与scope=prototype并用,用上面的代码测试了一下,结果是init被调用了2次,但是destroy未被调用过,不解。

结束总结

Spring配置文件提供了以下的配置手法及管理策略,对项目的管理能有不少的帮助,学习下来较为实用的还是setter注入。

1 Spring的注入类型

2 简单的属性注入

3 scope属性

4 集合注入MAP,SET,LIST

5 自动装配 autowire

6 生命周期lazy-init  和初始毁灭方法的调用 init-method,destroy-method

Spring框架配置beans.xml扩展的更多相关文章

  1. Spring框架配置beans.xml

    Spring学习笔记(一) 一.Spring 框架 Spring 是一个开源框架,是为了解决企业应用程序开发复杂性而创建的.框架的主要优势之一就是其分层架构,分层架构允许您选择使用哪一个组件,同时为 ...

  2. spring框架中beans.xml文件报错XmlBeanDefinitionStoreException

    第一次构建spring,实现简单的注入方式,就发生了beans.xml文件报错,报错信息如下图 org.springframework.beans.factory.xml.XmlBeanDefinit ...

  3. Spring 框架配置web.xml 整合web struts

    package cn.itcast.e_web; import java.io.IOException; import javax.servlet.ServletContext; import jav ...

  4. Spring框架之beans源码完全解析

    导读:Spring可以说是Java企业开发里最重要的技术.而Spring两大核心IOC(Inversion of Control控制反转)和AOP(Aspect Oriented Programmin ...

  5. Spring注解配置和xml配置优缺点比较

    Spring注解配置和xml配置优缺点比较 编辑 ​ 在昨天发布的文章<spring boot基于注解方式配置datasource>一文中凯哥简单的对xml配置和注解配置进行了比较.然后朋 ...

  6. 使用spring框架,用xml方式进行bean装配出现“The fully qualified name of the bean's class, except if it serves...”

    使用spring框架,用xml方式进行bean装配出现“The fully qualified name of the bean's class, except if it serves...”. 原 ...

  7. 0001 - Spring 框架和 Tomcat 容器扩展接口揭秘

    前言 在 Spring 框架中,每个应用程序上下文(ApplicationContext)管理着一个 BeanFactory,BeanFactory 主要负责 Bean 定义的保存.Bean 的创建. ...

  8. 最新 Eclipse IDE下的Spring框架配置及简单实例

    前段时间开始着手学习Spring框架,又是买书又是看视频找教程的,可是鲜有介绍如何配置Spring+Eclipse的方法,现在将我的成功经验分享给大家. 本文的一些源代码来源于码农教程:http:// ...

  9. 0044 spring框架的applicationContext.xml的命名空间

    Spring框架中,创建bean,装配bean,事务控制等,可以用xml配置或者注解扫描的方法实现.如果用注解扫描,在xml配置中得加上 <context:component-scan base ...

随机推荐

  1. .Net创建Windows服务完成批量导出功能(错误速查)

    无法打开计算机“.”上的服务控制管理器.此操作可能需要其他特权. 无法将类型为“Microsoft.Office.Interop.Word.ApplicationClass”的 COM 对象强制转换为 ...

  2. HDU3874 线段树 + 离线处理

    题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=3874 , 线段树(或树状数组) + 离线处理 下午做了第一道离线处理的题目(HDU4417),多少有点 ...

  3. IOS CALayer基本使用 (图层)

    ● 其实UIView之所以能显示在屏幕上,完全是因为它内部的一个图层(CALayer) ● 在创建UIView对象时,UIView内部会自动创建一个图层(即CALayer对象),通过UIView 的l ...

  4. POJ 3046 Ant Counting(递推,和号优化)

    计数类的问题,要求不重复,把每种物品单独考虑. 将和号递推可以把转移优化O(1). f[i = 第i种物品][j = 总数量为j] = 方案数 f[i][j] = sigma{f[i-1][j-k], ...

  5. 关于profile集合

    profile集合是mongodb的慢操作日志 > db.getProfilingStatus() { , , } 可以通过getProfilingStatus来查看当前profile设置 pr ...

  6. Object.prototype.toString的应用

    使用Object.prototype上的原生toString()方法判断数据类型,使用方法如下: Object.prototype.toString.call(value)1.判断基本类型: Obje ...

  7. vue中的过滤器

    过滤器 过滤器规则 Vue.js 允许你自定义过滤器,可被用于一些常见的文本格式化.过滤器可以用在两个地方: 双花括号插值{{}}和 v-bind 表达式 (后者从 2.1.0+ 开始支持).过滤器应 ...

  8. js中的||、&&与!用法

    &&和||在JQuery源代码内尤为使用广泛,由网上找了些例子作为参考,对其用法研究了一下: 1. && function a(){ alert("a&quo ...

  9. 【SAM manacher 倍增】bzoj3676: [Apio2014]回文串

    做法一:PAM:做法二:SAM+manacher.前缀树上倍增 Description 考虑一个只包含小写拉丁字母的字符串s.我们定义s的一个子串t的“出 现值”为t在s中的出现次数乘以t的长度.请你 ...

  10. XML字符串解析

    不多说,直接上代码: import java.io.StringReader; import org.dom4j.Document; import org.dom4j.DocumentExceptio ...