spring之bean学习笔记

整理学习的笔记 加深理解 精彩的人生需要一步一步的积累 加油

本文主要是学习spring容器bean的创建、bean的作用域、依赖注入、懒加载、初始化方法与销毁方法

详细的解释都在代码里面了 我就不多说了

测试代码SpringTest.java

package com.undergrowth.test;

import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.undergrowth.bean.service.IPersonDao;
import com.undergrowth.bean.serviceimple.PersonDao;

/*
* 这个测试用例主要是学习spring容器bean的创建、bean的作用域、依赖注入、懒加载、初始化方法与销毁方法
*/
public class SpringTest {

private static  AbstractApplicationContext ac;
private  IPersonDao ipd;
//在进行测试之前先进行spring的初始化
@BeforeClass
public  static void beforeTest(){
ac=new ClassPathXmlApplicationContext(new String[]{"applicationContext.xml","di.xml","scope.xml"});
}

//测试自动扫描功能
@Test
public void test() {
//获取通过自动扫描进行注册的bean
//如果是自动扫描注册的bean的话 其bean的id标示符应该是第一个字母小写 后面的单词就是驼峰法的命名规则
ipd=ac.getBean("personDao",PersonDao.class);
ipd.sayWhat("你好 spring");

}

//测试使用构造器创建的bean
@Test
public void test2() {
ipd=ac.getBean("personDao2",PersonDao.class);
ipd.sayWhat("你好 spring,我是使用构造器创建的bean");

}

//测试使用静态工厂创建的bean
@Test
public void test3() {
ipd=ac.getBean("personDao3",PersonDao.class);
ipd.sayWhat("你好 spring,我是使用静态工厂方法创建的bean");

}

//测试使用构造器和setter进行注入
@Test
public void test4() {
ipd=ac.getBean("personDao4",PersonDao.class);
ipd.sayWhat("你好 spring,我是使用构造器和setter进行注入");

}
//用于测试bean的作用范围
@Test
public void test56() {
ipd=ac.getBean("personDao6",PersonDao.class);
ipd=ac.getBean("personDao6",PersonDao.class);

}

/*测试bean的初始化与销毁*/
@Test
public void test7() {
ipd=ac.getBean("personDao7",PersonDao.class);

ac.close();
}
}

配置文件

applicationContext.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"
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-3.1.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd" >
<!-- 打开自动扫描注册类的功能
context:component-scan
自动的将类中使用 @Controller @Service @Repository @Component 进行注解的类 加入到spring的容器中进行管理
并且还隐式的将 AutowiredAnnotationBeanPostProcessor and CommonAnnotationBeanPostProcessor进行了注册
-->
<context:component-scan base-package="com.undergrowth.bean">
</context:component-scan>

<!-- 实例化bean共有三种方法 分别为使用构造器 使用静态工厂方法 使用实例工厂方法 -->
<!--  第一种 使用构造器 现在这种是使用无参数的构造器进行创建bean -->
<bean id="personDao2" class="com.undergrowth.bean.serviceimple.PersonDao"></bean>
<!-- 第二种 使用静态工厂方法 -->
<bean id="personDao3" class="com.undergrowth.utils.UnderBeanFactory" factory-method="createInstance"></bean>

</beans>

scope.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"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd" >

<!--
上面的PersonDao中的person属性 是通过Autowired进行依赖注入的 现在使用构造器参数和setter进行注入
并且加入了bean的范围测试
-->
<bean id="person5" class="com.undergrowth.bean.Person">
<property name="name" value="qq"></property>
<property name="age" value="208"></property>
</bean>
<!-- 默认bean的范围为singleton singleton表示在spring容器中只会有一个id为personDao5的实例 -->
<!-- 默认情况下,spring容器在初始化的时候会加载和配置scope为singleton的bean
但是可以使用lazy-init属性 设置其在使用getBean的时候进行加载 -->
<bean id="personDao5" class="com.undergrowth.bean.serviceimple.PersonDao" scope="singleton" lazy-init="true">
<constructor-arg index="0" value="你想说什么,bean的作用域测试"></constructor-arg>
<constructor-arg index="1" ref="person5"></constructor-arg>
</bean>
<!-- prototype表示在每一次获取bean的时候 都创建一个新的bean的实例
prototype在spring容器初始化的时候不会加载容器
在使用getBean的时候进行加载
-->

<bean id="personDao6" class="com.undergrowth.bean.serviceimple.PersonDao" scope="prototype"
>
<constructor-arg index="0" value="你想说什么,bean的作用域测试"></constructor-arg>
<constructor-arg index="1" ref="person5"></constructor-arg>
</bean>

<!-- 在创建容器的时候可以加入初始化方法和销毁方法
init-method-进行初始化工作
destroy-method-进行扫尾工作(AbstractApplicationContext才有close方法)
-->
<bean id="personDao7" class="com.undergrowth.bean.serviceimple.PersonDao"
init-method="init" destroy-method="close"></bean>

</beans>

di.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"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd" >

<!--
上面的PersonDao中的person属性 是通过Autowired进行依赖注入的 现在使用构造器参数和setter进行注入 -->
<bean id="person4" class="com.undergrowth.bean.Person">
<property name="name" value="undergrowth"></property>
<property name="age" value="108"></property>
</bean>
<bean id="personDao4" class="com.undergrowth.bean.serviceimple.PersonDao">
<constructor-arg index="0" value="你想说什么"></constructor-arg>
<constructor-arg index="1" ref="person4"></constructor-arg>
</bean>

</beans>

服务层代码

PersonDao.java

package com.undergrowth.bean.serviceimple;

import java.util.Date;

import org.aspectj.weaver.NewConstructorTypeMunger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.undergrowth.bean.Person;
import com.undergrowth.bean.service.IPersonDao;

//告知spring的容器 将该类加入到spring的容器中进行管理
@Service
public class PersonDao implements IPersonDao {

private String what;
//按照类型进行依赖注入person
@Autowired
private Person person;
public String getWhat() {
return what;
}
public void setWhat(String what) {
this.what = what;
}
public Person getPerson() {
return person;
}
public void setPerson(Person person) {
this.person = person;
}
public PersonDao(String what, Person person) {
super();
this.what = what;
this.person = person;
System.out.println(new Date().getTime());
}
public PersonDao() {
super();
}
/* (non-Javadoc)
* @see com.undergrowth.bean.serviceimple.IPersonDao#sayWhat()
*/
@Override
public void sayWhat(String what)
{
System.out.println("you say what:"+what+"\t"+this.what+"\t"+person);
}

public void init()
{
System.out.println("我在开始初始化工作");
}

public void close()
{
System.out.println("我在开始扫尾工作");
}

}

持久层代码

Person.java

package com.undergrowth.bean;

import org.springframework.stereotype.Repository;

//告知spring的容器 将该类加入到spring的容器中进行管理
@Repository
public class Person {
private String name;
private Integer age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
public Person() {
super();
//为了测试数据的方法  加入测试数据
name="张三";
age=20;
}
public Person(String name, Integer age) {
super();
this.name = name;
this.age = age;
}

}

用于静态工厂创建bean的类 UnderBeanFactory.java

package com.undergrowth.utils;

import com.undergrowth.bean.serviceimple.PersonDao;

/*
* 用于解释使用静态工厂方法创建的bean
*/
public class UnderBeanFactory {

public static Object createInstance()
{
return new PersonDao();
}
}