spring bean的实例化
构造器实例化
<!--
无参构造器实例化
-->
<bean id="student1" class="com.qfedu.entity.Student">
<property name="id" value="100"></property>
<property name="name" value="xiaoming"></property>
</bean>
静态工厂实例化
容器创建对象,不直接调用对象构造方法,而是调用静态工厂的创建对象的方法
好处:便于我们定制化创建对象,对象的初始化,需要访问网络中的数据
/**
* 静态工厂
* 静态方法创建对象
*/
public class StaticFactory {
/**
* 静态方法 创建对象
* @return
*/
public static Student createStudent(){
Student student = new Student();
// 好处就是 程序员可以 自定义 初始化对象,并交给spring容器创建
student.setId(123);
student.setName("小明");
return student;
}
}
<!--
告诉容器使用静态工厂 创建对象
class="com.qfedu.factory.StaticFactory" 静态工厂
factory-method="createStudent" 调用静态工厂的方法名
-->
<bean id="student2" class="com.qfedu.factory.StaticFactory" factory-method="createStudent">
</bean>
个人整理了一些资料,有需要的朋友可以直接点击领取。
实例工厂实例化
/**
* 实例工厂 创建对象
*/
public class Factory {
/**
* 实例方法 创建对象
* @return
*/
public Student createStudent(){
Student student = new Student();
// 好处就是 程序员可以 自定义 初始化对象,并交给spring容器创建
student.setId(123);
student.setName("小明");
return student;
}
}
<?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="factory" class="com.qfedu.factory.Factory">
</bean>
<!--
目标创建 student 使用实例工厂
factory-bean="factory" 引用实例工厂
factory-method="createStudent" 调用实例工厂中的实例 方法
-->
<bean id="student" factory-bean="factory" factory-method="createStudent">
</bean>
</beans>
工厂实例化的使用场景
工厂实例化作用:便于程序员自定义创建对象
使用场景:初始化数据库数据时,对数据库密码进行解密,将数据源放置到容器中,提高安全性
bean的作用域
作用域:就是bean 在容器中生存的范围
常用的:单例,原型
单例模式
<!--
让容器创建一个student
默认 该bean 作用域 是单例singleton scope="singleton"
单例singleton 无论用户是否获取该bean,容器在启动创建该bean,而且只创建一个 对应bean id为 student
-->
<bean id="student" class="com.qfedu.entity.Student" scope="singleton">
<property name="id" value="100"></property>
<property name="name" value="xiaoming"></property>
</bean>
原型测试
<!--
告诉容器创建一个 原型 bean id="student1"
什么时候创建? 容器启动不创将该bean,在用户获取时创建,而且每获取一次创建一个bean,容器只负责创建,
不负责持有,管理该bean
-->
<bean id="student1" class="com.qfedu.entity.Student" scope="prototype">
<property name="id" value="100"></property>
<property name="name" value="xiaoming"></property>
</bean>
测试
public class ScopeTest {
public static void main(String[] args) {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("scope/scope_bean.xml");
System.out.println("单例测试");
//单例的bena无论获取多少次都是单例
Student student1 = (Student) applicationContext.getBean("student");
Student student2 = (Student) applicationContext.getBean("student");
System.out.println("student1 == student2:" + (student1 == student2));
System.out.println("*********");
System.out.println("原型测试");
// 获取 原型bean, 每次获取都是一个新的对象,容器只负责创建,不负责持有,维护
Student student3 = (Student) applicationContext.getBean("student1");
Student student4 = (Student) applicationContext.getBean("student1");
System.out.println("student3 == student4:" + (student3 == student4));
}
}
bean的生命周期
bean:交给容器维护,容器管理bean
bean的生命周期 的bean 的作用域相关
singleton
Spring容器可以管理singleton作用域的Bean的生命周期,在此作用域下,Spring能够精确的知道该Bean何时被创建,何时初始化完成,以及何时被销毁。
容器创建bean,管理bean
容器初始化时创建 单例的 bean,并且持有bean, 容器销毁时 ,销毁bean
prototype
prototype作用域的Bean,Spring只负责创建,当容器创建了Bean实例后,Bean的实例就交给客户端代码来管理,Spring容器将不再跟踪其生命周期。
容器只创建bean不管理
容器初始化时,不会创建bean,只有在获取时才会创建bean,spring 只负责创建,不持有bean,也不负责销毁,还可以为bean 配置 init()初始化方法,destroy() 销毁方法
public class Student implements Serializable {
private int id;
private String name;
/**
* 初始化 资源
*/
public void init(){
System.out.println("Student 初始化方法");
}
/**
* 释放资源
*/
public void destroy(){
System.out.println("Student 销毁方法");
}
。。。。
}
<?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 scope="singleton"
init-method="init" bean 在创建时调用 初始化方法
destroy-method="destroy" 容器销毁 方法
-->
<bean id="student1" class="com.qfedu.entity.Student" scope="singleton"
init-method="init" destroy-method="destroy">
<property name="id" value="100"></property>
<property name="name" value="xiaoming"></property>
</bean>
<!--
原型bean scope="prototype"
init-method="init" bean 在创建时调用 初始化方法
destroy-method="destroy" 容器销毁 方法
-->
<bean id="student2" class="com.qfedu.entity.Student" scope="prototype"
init-method="init" destroy-method="destroy">
<property name="id" value="100"></property>
<property name="name" value="张三"></property>
</bean>
</beans>
测试:
/**
*bena的生命周期
*/
public class LifeTest {
public static void main(String[] args) {
ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("life/life_bean.xml");
Student student1 = (Student) classPathXmlApplicationContext.getBean("student1");
System.out.println(student1);
System.out.println("容器销毁");
// 明示销毁容器,此时会调用容器中所有bean destroy() 方法
// 单例bean 调用 destroy()
// 原型bean 不会调用 destroy() 因为容器不持有该bean
classPathXmlApplicationContext.destroy();
}
}
Bean的装配
什么Bean的装配?
就是bean 属性的设置,以及bean 之间依赖关系的配置
基于XML的装配
property和构造方法设置值(无参和有参)
<?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">
<!--
通过无参构造 使用setter 初始化bean
-->
<bean id="student1" class="com.qfedu.entity.Student">
<property name="id" value="100"></property>
<property name="name" value="xiaoming"></property>
<property name="sex" value="F"></property>
<property name="course" >
<list>
<value>Java</value>
<value>UI</value>
<value>H5</value>
<value>php</value>
</list>
</property>
</bean>
<!--
通过有参构造创建 bean
public Student(int id, String name, String sex, List<String> course)
0 1 2 3
<constructor-arg index="0" value="111"></constructor-arg> 为每一个构造方法的参数设置
属性
-->
<bean id="student1" class="com.qfedu.entity.Student">
<constructor-arg index="0" value="111"></constructor-arg>
<constructor-arg index="1" value="zhangsan"></constructor-arg>
<constructor-arg index="2" value="F"></constructor-arg>
<constructor-arg index="3" >
<list>
<value>Java</value>
<value>UI</value>
<value>H5</value>
<value>php</value>
</list>
</constructor-arg>
</bean>
</beans>
测试
public class XmlTest {
public static void main(String[] args) {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("xml/xml_bean.xml");
Student student1 = (Student) applicationContext.getBean("student1");
System.out.println("student1 = " + student1);
Student student2 = (Student) applicationContext.getBean("student2");
System.out.println("student2 = " + student2);
}
}
基于注解的装配
注解:就是一个标记,记号
通过注解创建bean 并管理bean 之间的依赖关系
注入的注解
一个实例中的属性可以通过以下注解从容器获取对应的bean,并注入进来:
@Autowired:用于对Bean的属性变量、属性的setter方法及构造方法进行标注,配合对应的注解处理器完成Bean的自动配置工作
@Qualifier:与@Autowired注解配合使用,会将默认的按Bean类型装配修改为按Bean的实例名称装配,Bean的实例名称由@Qualifier注解的参数指定。
@Resource:其作用与Autowired一样。@Resource中有两个重要属性:name和type。Spring将name属性解析为Bean实例名称,type属性解析为Bean实例类型。
@Autowired + @Qualifier
激活注入的注解:
<!--
这是一个开关,激活 @Autowired @ Resource 、@ PostConstruct、@ PreDestroy
让他们生效
-->
<context:annotation-config></context:annotation-config>
加入注解到容器中:
<!--
将StudentDaoImpl加入到容器中StudentDaoImpl
-->
<bean id="studentDao1" class="com.qfedu.dao.StudentDaoImpl"></bean>
<bean id="studentDao2" class="com.qfedu.dao.StudentDaoImpl"></bean>
<!--
将StudentServiceImpl加入到容器中
-->
<bean id="studentService" class="com.qfedu.service.StudentServiceImpl"></bean>
装配:
public class StudentServiceImpl implements StudentService{
/*@Autowired 不需要 setter方法支持
* 意义: 1.首先根据注解的类型 去容器中查找 如果只有一个,则设置
* 2.如果按照类型查找到 多个 ,则使用 变量名( private StudentDao studentDao) 作为id 去容器中查找
* 3.如果按照变量名找不到,可以使用@Qualifier("studentDao2") 配置,按照传递的参数作为iD 查找
*/
// 去容器中查找 StudentDao 对应实例,并将当前 属性引用
@Autowired
@Qualifier("studentDao2")//如果找到多个使用 @Qualifier区分
private StudentDao studentDao;
// public void setStudentDao(StudentDao studentDao){
// this.studentDao = studentDao;
// }
public Student findStudentById(int id) {
return studentDao.findStudentById(id);
}
}
@Resource
激活注入的注解:
<!--
这是一个开关,激活 @Autowired @ Resource 、@ PostConstruct、@ PreDestroy
让他们生效
-->
<context:annotation-config></context:annotation-config>
加入注解到容器中:
<!--
将StudentDaoImpl加入到容器中StudentDaoImpl
-->
<bean id="studentDao1" class="com.qfedu.dao.StudentDaoImpl"></bean>
<bean id="studentDao2" class="com.qfedu.dao.StudentDaoImpl"></bean>
<!--
将StudentServiceImpl加入到容器中
-->
<bean id="studentService" class="com.qfedu.service.StudentServiceImpl"></bean>
装配:
public class StudentServiceImpl implements StudentService{
/*
* @Resource 也是 将容器中的bean 注入到当前对象中
* 意义:
* 1.首先按照声明 属性名作为id 去容器中查找(private StudentDao studentDao ),
* 2.如果没有找到 按照类型查找 ,如果查找到一个则设置值, 如果查到多个,则进入第三步
* 3.@Resource(name = "studentDao2"): 如果找到多个类型的bean 必须传入name 作为id 进行限定
*
* @Autowired @Resource 的区别?
*
* 1. @Resource(name = "studentDao2") 等价于 @Autowired @Qualifier
* 2.意义
* 3.@Resource 是jdk 注解 @Autowired 是spring 注解
* */
@Resource(name = "studentDao2")
private StudentDao studentDao;
// public void setStudentDao(StudentDao studentDao){
// this.studentDao = studentDao;
// }
public Student findStudentById(int id) {
return studentDao.findStudentById(id);
}
}
总结
@Autowired 不需要 setter方法支持
- 意义: 1.首先根据注解的类型 去容器中查找 如果只有一个,则设置
- 2.如果按照类型查找到 多个 ,则使用 变量名( private StudentDao studentDao) 作为id 去容器中查找
- 3.如果按照变量 名找不到,可以使用@Qualifier(“studentDao2”) 配置,按照传递的参数作为iD 查找
* - @Resource 也是 将容器中的bean 注入到当前对象中
- 意义:
- 1.首先按照声明 属性名作为id 去容器中查找(private StudentDao studentDao ),
- 2.如果没有找到 按照类型查找 ,如果查找到一个设置值 如果多个,则进入第三部
- 3.@Resource(name = “studentDao2”) 如果找到多个类型的bean 必须传入name 作为id 进行限定
* - @Autowired @Resource 的区别?
* - @Resource(name = “studentDao2”) 等价于 @Autowired @Qualifier
- 2.意义
3.@Resource 是jdk 注解 @Autowired spring 注解
*生成bean的注解
@Component
//@Component // 在容器中加入bean 默认id studentServiceImpl
@Component(“studentService”) // 在容器中加入bean id studentService
以下三个用法和 @Component 一样是@Component 的子注解
@Service 用于service
@Controller 用于控制层
@Repository 用于持久层 dao
<?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:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!--
包扫描器 :
激活 注入注解 @Autowired @ Resource
激活生成bean 的注解
@Component
//@Component // 在容器中加入bean 默认id studentServiceImpl
@Component("studentService") // 在容器中加入bean id studentService
以下三个用法和 @Component 一样是@Component 的子注解
@Service 用于service
@Controller 用于控制层
@Repository 用于持久层 dao
-->
<context:component-scan base-package="com.qfedu"></context:component-scan>
</beans>
//@Component // 在容器中加入bean 默认id studentServiceImpl
//@Component("studentService") // 在容器中加入bean id studentService
@Service("studentService")// 加入到容器 id studentService
public class StudentServiceImpl implements StudentService {
// 去容器中查找 StudentDao 对应实例,并将当前 属性引用
/**
* @Autowired 不需要 setter方法支持
* 意义: 1.首先根据注解的类型 去容器中查找 如果只有一个,则设置
* 2.如果按照类型查找到 多个 ,则使用 变量名( private StudentDao studentDao) 作为id 去容器中查找
* 3.如果按照变量 名找不到,可以使用@Qualifier("studentDao2") 配置,按照传递的参数作为iD 查找
*
* @Resource 也是 将容器中的bean 注入到当前对象中
* 意义:
* 1.首先按照声明 属性名作为id 去容器中查找(private StudentDao studentDao ),
* 2.如果没有找到 按照类型查找 ,如果查找到一个设置值 如果多个,则进入第三部
* 3.@Resource(name = "studentDao2") 如果找到多个类型的bean 必须传入name 作为id 进行限定
*
* @Autowired @Resource 的区别?
*
* 1. @Resource(name = "studentDao2") 等价于 @Autowired @Qualifier
* 2.意义
* 3.@Resource 是jdk 注解 @Autowired spring 注解
*
*/
// @Autowired
// @Qualifier("studentDao2")//如果找到多个使用 @Qualifier区分
@Resource
private StudentDao studentDao ;
// public void setStudentDao(StudentDao studentDao) {
// this.studentDao = studentDao;
// }
public Student findStudentById(int id) {
return studentDao.findStudentById(id);
}
}
//@Component// 将当前类 创建一个bean 加入到容器中 id studentDaoImpl
@Repository // 加入到容器 id studentDaoImpl
public class StudentDaoImpl implements StudentDao{
public Student findStudentById(int id) {
// 模拟取数据库查询
Student student = new Student();
student.setId(id);
student.setName("XXXXX");
return student;
}
}
测试:
/**
* 自动转配
*/
public class AnnootaionTest {
public static void main(String[] args) {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("annotation/auto_annotation.xml");
StudentService studentService = (StudentService) applicationContext.getBean("studentService");
Student student = studentService.findStudentById(12);
System.out.println("student"+student);
}
}
基于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="studentDao1" class="com.qfedu.dao.StudentDaoImpl"></bean>
<bean id="studentDao" class="com.qfedu.dao.StudentDaoImpl"></bean>
<!--
加入到容器中 StudentServiceImpl
autowire="byName" 容器中的属性 会根据属性名作为id 去容器中查找
autowire="byType" 容器中的属性 会根据属性类型 去容器中查找
autowire="constructor" 根据构造方法设置 属性
-->
<bean id="studentService" class="com.qfedu.service.StudentServiceImpl" autowire="byName">
</bean>
</beans>
最后
感谢大佬们能看到这里,来都来了不妨点个赞再走呗
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用
。你还可以使用@
来通知其他用户。