1.Spring 是什么
Spring 是一个开源的控制反转的(IoC) 和面向切面的(AOP) 的容器框架。它主要目的是简化企业开发。
控制反转: 所谓控制反转就是应用本身不负责依赖对象的创建及维护,依赖对象的创建及维护是由外部容器负责的。这样控制权就由应用转移到了外部容器,控制权的转移就是所谓的反转。
依赖注入: 所谓依赖注入就是 在运行期,由外部容器动态地将依赖对象注入到组件中。
2.使用spring 2.5 需要的jar
必须使用的是 spring.jar 和 commons-logging.jar
如果使用了切面编程(aop),还需要
aspectjweaver.jar
aspectjrt.jar
cglib-nodep-2.1_3.jar
如果使用了JSR-250中的注解,还需要
common-annotations.jar
3.实例化spring容器
方法一: 在类路径下寻找配置文件来实例化容器
ApplicationContext ctx = new ClassPathXmlApplicationContext(new String[]{"beans.xml"});
方法二:
在文件系统路径下寻找配置文件来实例化容器(不常用)
ApplicationContext ctx = new FileSystemXmlApplicationContext(new String[]{"d://beans.xml"});
4.手动添加schema文件
windows --> perferences --> myeclipse --> files and editors -->xml --> xmlcatalog
点击"and" , 在Location中选择"文件路径" 将 Key Type 改为Schema location , Key 改为 原有路径加上文件名如 /beans-2.5.xsd
5.三种实例化bean的方式
(1)使用类构造器实例化
<bean id="personService" class="com.hf.service.impl.PersonServiceBean" />
(2)使用静态工厂方法实例化
<bean id="personService2" class="com.hf.service.impl.PersonServiceBeanFactory"
factory-method="createPersonServiceBean" />
package com.hf.service.impl;
public class PersonServiceBeanFactory {
public static PersonServiceBean createPersonServiceBean(){
return new PersonServiceBean();
}
}
(3)使用实例工厂方法实例化
<bean id="personServiceFactory" class="com.hf.service.impl.PersonServiceBeanFactory" />
<bean id="personService3" factory-bean="personServiceFactory" factory-method="createPersonServiceBean2" />
package com.hf.service.impl;
public class PersonServiceBeanFactory {
public PersonServiceBean createPersonServiceBean2(){
return new PersonServiceBean();
}
}
6.默认情况下
<bean id="personService" class="com.hf.service.impl.PersonServiceBean" />
PersonService personService= (PersonService)cxt.getBean("personService");
每次调用bean 获取的是同一个引用(单实例)
<bean id="personService" class="com.hf.service.impl.PersonServiceBean" scope="prototype"/>
每次调用bean 获取的是新的引用
疑问:Spring作用域都有哪些 scope
7.初始化bean
默认情况下 bean 在spring容器实例化时就被实例化了
scope="prototype" 时 是在调用getBean方法是实例化bean的
lazy-init="true" 时 是在调用getBean方法是实例化bean的 (延迟初始化)
在beans 节点 输入default-lazy-init="true" 则所有的bean对象都会(延迟初始化)
init-method="init" bean被实例化后就执行的初始化方法 init为要初始化的方法名称
destroy-method="destroy" bean被销毁后执行的方法 destroy为要销毁bean的方法名称
容器被关闭时及bean被销毁
<bean id="personService" class="com.hf.service.impl.PersonServiceBean"
init-method="init" destroy-method="destroy"/>
AbstractApplicationContext cxt = new ClassPathXmlApplicationContext("beans.xml");
cxt.close();
8. 注入集合的方法
ApplicationContext cxt = new ClassPathXmlApplicationContext("beans.xml");
PersonService personService1= (PersonService)cxt.getBean("personService");
------Set集合-------------------------------------------
实现类
private Set<String> sets = new HashSet<String>();
public Set<String> getSets() {
return sets;
}
public void setSets(Set<String> sets) {
this.sets = sets;
}
接口
public Set<String> getSets();
配置xml
<bean id="personService" class="com.hf.service.impl.PersonServiceBean">
<property name="sets">
<set>
<value>第1个</value>
<value>第2个</value>
<value>第3个</value>
</set>
</property>
</bean>
---------List集合--------------------------------------------
同理
private List <String> lists = new ArrayList<String>();
<property name="lists">
<list>
<value>第w1个</value>
<value>第w2个</value>
<value>第w3个</value>
</list>
</property>
---------Properties 集合---------------------------------------
实现类
private Properties properties = new Properties();
public Properties getProperties() {
return properties;
}
public void setProperties(Properties properties) {
this.properties = properties;
}
接口
public Properties getProperties();
xml配置
<bean id="personService" class="com.hf.service.impl.PersonServiceBean">
<property name="properties">
<props>
<prop key="key1">value1</prop>
<prop key="key2">value2</prop>
<prop key="key3">value3</prop>
</props>
</property>
</bean>
输出
for(Object key : personService1.getProperties().keySet()){
System.out.println(key+"="+personService1.getProperties().getProperty((String)key));
}
--------Map集合-----------------------------------
实现类
private Map<String,String> maps =new HashMap<String,String>();
public Map<String, String> getMaps() {
return maps;
}
public void setMaps(Map<String, String> maps) {
this.maps = maps;
}
接口
public Map<String, String> getMaps();
xml配置
<bean id="personService" class="com.hf.service.impl.PersonServiceBean">
<property name="maps">
<map>
<entry key="key-1" value="value-1"></entry>
<entry key="key-2" value="value-2"></entry>
<entry key="key-3" value="value-3"></entry>
</map>
</property>
</bean>
输出
for(String key : personService1.getMaps().keySet()){
System.out.println(key+"="+personService1.getMaps().get(key));
}
9.通过构造器的方式注入值
实现类
private PersonDao persondao;
private String name;
//构造函数
public PersonServiceBean(PersonDao persondao, String name) {
this.persondao = persondao;
this.name = name;}
//打印控制台
public void save(){
System.out.println(name+ persondao.show());
}
xml配置
<bean id="personDao" class="com.hf.dao.impl.PersonDaoBean" />
<bean id="personService" class="com.hf.service.impl.PersonServiceBean">
<constructor-arg index="0" type="com.hf.dao.PersonDao" ref="personDao" />
<constructor-arg index="1" value="马总" />
</bean>
xml 手工注入分 构造器注入和属性(get set)注入
依赖注入还有注解的方式
包括注解方式 及以上方式都属于 手工注入
注解注入方式的好处是:是xml文件简化减小臃肿
自动注入方式(不建议使用)
<bean id="personDao1" class="com.hf.dao.impl.PersonDaoBean"></bean>
<bean id="personService" class="com.hf.service.impl.PersonServiceBean" autowire="byType">
autowire属性如下:
. byType:按类型装配,可以根据属性的类型, 在容器中找到跟该类型匹配的bean. 如果发现多个则将抛出异常,如果没找到及属性值为null.
. byName: 按名称装配,可以根据属性的名称, 在容器中寻找跟该属性名相同的bean,如果没找到及属性为null。
. constructor与byType 的方式类似,不同之处在于它应用于构造器参数。如果在容器中没有中找到与构造器参数类型一致的bean ,那么将会抛出异常。
. autodetect:通过bean类型的自省机制(introspection)来决定是使用constructor还是使用byType方式进行自动装配。
如果发现默认的构造器,那么将使用byTypte 方式。
autowire="byName"按属性名称装配 没找到返回null