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>
集体整顿了一些材料，有须要的敌人能够间接点击支付。
Java 基础知识大全
22 本 Java 架构师外围书籍
从 0 到 1Java 学习路线和材料
1000+ 道 2021 年最新面试题
实例工厂实例化
/**
* 实例工厂 创建对象
*/
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>
最初
感激大佬们能看到这里，来都来了无妨点个赞再走呗