发表于： 2017-11-28 22:05:36
1 782
今天完成的事情：
正式进入了Spring的学习.
①最基本的Spring配置
<?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="helloImp" class="com.myspring.demo.HelloImp">
<property name="name" value="剑飞"/>
</bean>
<bean id="helloImp2" class="com.myspring.demo.HelloImp">
<property name="name" value="飞天小女警"/>
</bean>
<bean id="baoda1" class="com.myspring.demo.HelloImp2">
<property name="time" value="99"/>
</bean>
</beans>
这是一个最基本的Spring配置文件,用以操作生成bean类实例
<beans ...... 这个标题头是一些约束以及依赖文件,有网络直接这个模板就可以了,会自动缓存到本地
<bean></bean>就是一个bean类的映射.
②获取bean类工厂方式有四种:
1.通过类背身构造器实例化.
package com.myspring.ioc.factory;
/**
* @author Arike
* Create_at 2017/11/28 18:11
*/
public class BeanImp1 implements IBean {
//通过类本身构造器实例化
public BeanImp1(){
System.out.println("BeanImp1实例化");
}
}
<!--①构造器实例化方式-->
<bean id="imp1" class="com.myspring.ioc.factory.BeanImp1"/>
这是最常用也是最简单的,只需要一个实现类就可以了.
2.静态工厂
BeanImp2
package com.myspring.ioc.factory;
/**
* @author Arike
* Create_at 2017/11/28 18:20
*/
public class BeanImp2 implements IBean {
public BeanImp2() {
System.out.println("BenaImp2实例化");
}}
BeanImp2StaticFactory
package com.myspring.ioc.factory;
/**
* @author Arike
* Create_at 2017/11/28 18:21
*/
public class BeanImp2StaticFactory {
//私有静态工厂的构造
private BeanImp2StaticFactory() {}
//提供公开静态的工厂方法获取BeanImp3对象.
public static BeanImp2 getBeanImp2() {
return new BeanImp2();
}
}
配置文件:
<!--②静态工厂方式实例化-->
<bean id="imp2" class="com.myspring.ioc.factory.BeanImp2StaticFactory" factory-method="getBeanImp2"/>
3.实例工厂方式实例化.
Bean:
package com.myspring.ioc.factory;
/**
* @author Arike
* Create_at 2017/11/28 18:27
*/
public class BeanImp3 implements IBean {
public BeanImp3(){
System.out.println("BeanImp3实例化");
}
}
BeanFactory:
package com.myspring.ioc.factory;
/**
* @author Arike
* Create_at 2017/11/28 18:31
*/
public class BeanImp3Factory {
//通过实例工厂方式获取BeanImp3实例化对象
public BeanImp3 getBeanImp3() {
return new BeanImp3();
}
}
<!--③实例工厂方式实例化-->
<bean id="imp3Factory" class="com.myspring.ioc.factory.BeanImp3Factory"/>
<bean id="imp3" factory-bean="imp3Factory" factory-method="getBeanImp3"/>
实例工厂和静态工厂在配置文件的区别,
静态工厂:直接可以声明静态工厂并配置静态方法.
实例工厂:需要先配置实例工厂,再配置bean类,在bean类里调用实例工厂的方法.
4.通过实现FactoryBean,实例工厂变种,配合其他框架使用.LocalSessionFactoryBean
Bean类:
package com.myspring.ioc.factory;
/**
* @author Arike
* Create_at 2017/11/28 18:36
*/
public class BeanImp4 implements IBean {
public BeanImp4(){
System.out.println("Bean4Imp4实例初始化");
}
}
BeanSessionFactory
package com.myspring.ioc.factory;
import org.springframework.beans.factory.FactoryBean;
/**
* @author Arike
* Create_at 2017/11/28 18:39
*/
public class BeanImp4SessionFactory implements FactoryBean<BeanImp4> {
@Override
public BeanImp4 getObject() throws Exception {
return new BeanImp4();
}
@Override
public Class<?> getObjectType() {
return BeanImp4.class;
}
@Override
public boolean isSingleton() {
return true;
}
}
配置文件:
<!-- ④实现FactoryBean接口实例化：实例工厂变种：集成其他框架使用：LocalSessionFactoryBean
这个有区别,class这里限定的是LocalSessionFactoryBean的类,而不是我们需要的bean类-->
<bean id="imp4" class="com.myspring.ioc.factory.BeanImp4SessionFactory" />
这里的bean类配置和普通有区别,这里直接把实现了FactoryBean的实现类型配置进去,他会自动调用里面的getObject方法.类似于实例化的bean类配置,不过更智能,自动化.
③配置文件的一些限制用法,
1.initialize 初始化
<?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" default-lazy-init="false">
<!-- default-init-method="true" 是设置全局延迟初始化
init =initialize 初始化 lazy-init延迟初始化,默认default是没有延迟
true是延迟,false不延迟 -->
<bean id="some1" class="com.myspring.ioc.initialize.SomeBeanImp" lazy-init="true"/>
</beans>
2.scope
<?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" default-lazy-init="true" >
<!--单例实现-->
<bean id="imp1" class="com.myspring.ioc.scope.BeanImp" scope="singleton" init-method="init" destroy-method="close" />
<!--多例实现-->
<bean id="imp1more" class="com.myspring.ioc.scope.BeanImp" scope="prototype" init-method="init" destroy-method="close" />
</beans>
3.
<!--单例实现-->
<bean id="imp1" class="com.myspring.ioc.scope.BeanImp" scope="singleton" init-method="init" destroy-method="close" />
<!--多例实现-->
<bean id="imp1more" class="com.myspring.ioc.scope.BeanImp" scope="prototype" init-method="init" destroy-method="close" />
</beans>
init-method以及destory-method
分别对应初始化之后使用的方法,以及ioc容器回收前使用的方法.用以驱动加载和资源回收.
如果bean类限制为多例模式,则不会自动运行destory,需要自己手动调用.
@Test
//单例模式:自动运行初始化方法以及销毁(资源回收方法)
public void autoMethod() {
//在获取bean实例的时候就会执行初始化以及init方法,然后执行自定义的method方法,最后才会执行close回收资源.
ctx.getBean("imp1", BeanImp.class).run();
}
@Test
//多例模式:自动运行初始化方法,不会自动执行销毁
public void halfAuto() {
BeanImp bi = ctx.getBean("imp1more", BeanImp.class);
bi.run();
//需要手动执行资源回收方法
bi.close();
}
④多例模式和单例模式初始化的区别
@Test
//单例作用域只会初始化一次,得到的三个实例都指向同一个对象
public void sigletonBean() throws Exception {
System.out.println(ctx.getBean("imp1", IBean.class));
System.out.println(ctx.getBean("imp1", IBean.class));
System.out.println(ctx.getBean("imp1", IBean.class));
}
@Test
//多例作用域每次获取bean类都会初始化一次,每次的对象都不相同
public void prototypeBean() throws Exception {
System.out.println(ctx.getBean("imp1more", IBean.class));
System.out.println(ctx.getBean("imp1more", IBean.class));
System.out.println(ctx.getBean("imp1more", IBean.class));
System.out.println(ctx.getBean("imp1more", IBean.class));
}
⑤:Spring自己的测试控制
SpringIOC不仅仅是反转对bean对象的控制,连junit4测试也要给他控制,就很爽.
package com.myspring.ioc.scope;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/**
* @author Arike
* Create_at 2017/11/28 19:45
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:com/myspring/ioc/scope/IBeanSpring.xml")
public class IBeanTest {
@Autowired
ApplicationContext ctx;
三个关键注解:
@RunWith 用以告诉JVM虚拟机,该测试在哪个类里去运行.
@ContextConfiguration 关联需要测试的接口Spring配置文件
@Autowired 直接通过设定好的配置文件去获取容器.(并不是生成,在ContextConfiguration已经生成了所需要的IOC容器)
明天计划的事情：
继续Spring的ioc(反转控制)和DI(依赖注入)的学习
遇到的问题：
对LocalSessionFactoryBean的实际意义还不明了.
收获：
对Spring的IOC和DI有了初步认识.
禅道:http://task.ptteng.com/zentao/project-burn-414.html
返回列表
评论