Spring
1.SpringIOC ★★★
问题引入：
项目中Servlet需要Service Service需要Dao 我们是手动的通过new的方式提供的，会出现一些问题：
1. 所有的Service或者dao都是new出来的，代码直接耦合再一起，我们设计的目的尽量做到：高内聚低耦合。如果Service的实现或者dao 实现需要修改，则需要把所有代码中，所有new的地方都要改一遍。
2. 所有代码都需要修改，不光是工作两的变化，而且需要重新编译。
3. 维护扩展不方便，我们的关注点必须考虑对象的整个创建过程和初始化过程。
改进图示：
改造的思路：
-
出现以上问题的主要原因就是：
开发人员自己手动的处理了各层对象的创建过程和相互之间的依赖关系管理，所有想要降低各层之间的耦合，出发点就是b把new的过程从开发人员任务中去掉。
- 达成目标：
对象的创建权限由我们(开发人员)，交给BeanFactory
对象中的依赖关系的赋值，由我们 也交给了工厂自己赋值。
-
总结：
对象创建权限的变化(我们-工厂)的思想 叫做IOC控制反转，工厂可以看作是IOC思想的一种具体实现，叫做IOC容器。
对象之间依赖关系自动赋值，叫依赖注入(DI)
-
bean标签中如果没有写id属性，那么就说明在装配的时候 是按照类型装配的
-
bean标签的autowire属性：自动装配
- byType：根据类型装配 如果一个类型存在多个对象，那么不会报错，也不会注入，可能会出现空指针异常
- byName：根据属性名字进行装配，属性就是当前bean标签标识的类属性
-
Spring 简介
Spring Framwork 基础引擎
Spring Framwork是一个免费开源的实现了控制反转IOC、依赖注入(DI)和AOP面向切面变成的轻量级的、非侵入式的框架。
Spring Framwork中包括了IOC、Context上下文管理、Bean管理、AOP、Spring MVC等模块
MVC：Model(数据) View(视图)jsp Controller(控制)Servlet
IOC控制反转的特点
不需要主动new对象，而是描述对象如何被创建 交给BeanFactory创建 是被动实例化
不需要主动装配对象之间的依赖关系，而是描述需要哪个服务(组件)，IOC自动装配，被动接收装配
IOC就是主动变被动，减少类之间依赖的设计思想
IOC反转的什么？
正常时我们对象主动控制去获得依赖对象
反转是 由容器来帮忙创建和注入依赖对象，由容器查找创建对象，我们被动接收
依赖注入DI
就是用来表述对象和对象之间的依赖关系
由容器动态的将某个依赖关系注入到组件之中，依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。
面向切面AOP
通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。
AOP是OOP的延续，是软件开发中的一个热点，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
轻量级
非侵入式
非侵入式设计将客户端一部分功能拿到框架中用
侵入式是设计这将框架功能推给客户端
总结
总而言之，开发人员中需要关注核心业务，非核心的业务统统交给Spring
- 第一个IOC程序
1. 首先：
创建Maven工程，在POM.xml文件总导入Spring的坐标信息
此处导入的是Spring-context表示上下文
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.4</version>
</dependency>
2. 创建beans.xml文件
此文件中书写由BeansFactory创建对象的属性和依赖关系
通用头文件：
<?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-4.0.xsd">
</beans>
文件内容解析：
xmlns="http://www.springframework.org/schema/beans"
规定了当前默认命名空间的声明，这句会告诉schema验证其，在这个xml文档中使用的所有元素都被声明于xmlns对应的命名空间中
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
为当前的命名空间创建了实例对象 类似于java对象
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd"
xsi也是一个命名空间，表示使用指定的路径xsd文件
schemaLocation 属性要求有两个值 第一个是命名空间 第二个是xsd的位置
schema = 概要 扩展名为xsd文件 XML Schemas Definition
Xml的schema ： Schema 比 DTD 更强大
Schema 最重要的能力之一就是对数据类型的支持。
DTD Schema
DTD不遵守XML语法 Schema基于XML语法
DTD数据类型有限 Schema大大扩充了数据类型
DTD不支持命名空间 Schema支持命名空间
具体实例：
<?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-4.0.xsd">
<!--无参数构造方法-->
<bean id="stu" class="com.etoak.student.entity.Student" ></bean>
<!--带参数构造方法-->
<bean id="per" class="com.etoak.student.entity.Person">
<constructor-arg name="email" value="etoak@qq.com"></constructor-arg>
<constructor-arg name="address" value="济南" ></constructor-arg>
</bean>
<!--了解 ：静态工厂方法和实例工厂方法-->
<!--静态工厂方法-->
<bean id="stu1" class="com.etoak.student.factory.StudentFactory"
factory-method="getStu"></bean>
<!--实例工厂方法-->
<bean id="f" class="com.etoak.student.factory.StudentFactory"></bean>
<bean id="stu2" factory-bean="f"
factory-method="getStu1"></bean>
<!--实现FactoryBean接口 来构造复杂对象-->
<bean id="stu3" class="com.etoak.student.factory.StudentFactoryBean"></bean>
</beans>
3. 创建实体类：
正常情况 是先创建实体类，根据实体类 来书写beans.xml文件
4. 创建测试类：
4.1 读取解析xml文件：
//方式1
BeanFactory f1 = new XmlBeanFactory(new FileSystemResource("xml的绝对路径"));
//方式2 最常用
ApplicationContext f = new ClassPathXmlApplicationContext("xml文件名");
//上述二者的区别？
Beanfactory 延迟创建 调用getBean()方法时，才会创建对象
ApplicationContext 立即加载 在读取xml文件中，就会根据beans把对象创建出来
4.2 调用getBean()
IOC创建对象的方法 xml
- 创建带参的 constructor-arg标签
<bean id="per" class="com.etoak.student.entity.Person">
<constructor-arg name="email" value="email@qq.com" />
<constructor-arg name="address" value="山东省"/>
</bean>
- 无参构造
<bean id="stu" class="com.etoak.student.entity.Student"/>
-
静态工厂方法 需要创建一个工厂类，类中有一个静态的方法，方法中new一个对象
但是 并不会创建这个工厂的实例对象
使用factory-method属性 直接写 代表是静态的
<!--静态工厂方法--> <bean id="stu1" class="com.etoak.student.factory.StudentFactory" factory-method="getStu" /> -
实例工厂方法
- factory-bean：表示实例化的工厂是谁，需要先创建出工厂类的对象
- factory-method：再通过工厂的对象调用方法，创建对象
<bean id="f" class="com.etoak.student.factory.StudentFactory"/> <bean id="stu2" factory-bean="f" factory-method="getStu1" /> -
实现FactoryBean接口
- 适合用在 构造复杂的对象
- 底层有非常复杂的创建对象的过程
<bean id="stu3" class="com.etoak.student.factory.StudentFactoryBean" /> 新建一个类 实现接口FactoryBean 实现抽象方法 getObject() 返回创建的对象 getObjectType() 返回对象的类型 -
注解★★★ 使用注解创建的对象是无参的构造方法
- @Component：写在要创建对象的类上面，相当于写了个bean id默认是类名小写，class属性指向当前类，这是一个通用的注解
- @Controller：用在控制层
- @Service：用在服务层
- @Repository：用在dao层
注意：写了注解以后，要在xml文件中使用context包下的 component-scan开启组件扫描
而且就不需要书写beans标签了
<context:component-scan base-package="com.etoak.student.annotation"></context:component-scan> component-scan:开启组件扫描 base-package：从哪个包下开始扫描
IOC给对象的属性赋值
-
xml的方式 实体类要提供setter方法
<bean id="stuController" class="com.etoak.student.xml.controller.StudentController" > <!-- 此处通过Property标签来给实体类中的属性赋值 name属性对应实体类中的属性名 ref表示引用的下一层子标签 值对应着引用的bean标签的id值 value是直接赋简单值 通过setter方法 --> <property name="service1" ref="sv1"></property> <property name="service2" ref="sv2"></property> <property name="age" value="18"></property> </bean> <bean id="sv1" class="com.etoak.student.xml.service.StudentService1"> <property name="dao1" ref="dao1"></property> <property name="dao2" ref="dao2"></property> </bean> <bean id="sv2" class="com.etoak.student.xml.service.StudentService2"> </bean> -
注解的方式 不需要实体类提供setter方法
@Autowired //来自spring-beans的包 //默认按照类型匹配，如果一个类型的对象有多个，则默认按照名字匹配 //可以通过@Qulifier设置名字，如果设置@Qulifier,则一定按照设置的名字匹配 @Autowired @Qulifier("student") private Student stu; @Resource //来自javax.annotation包 //@Resource(name="xxx")默认按照名字进行匹配，如果没有设置name，则默认按照类中属性名字进行匹配 //@Resource(type=xxx.class) 按照设置的类型进行匹配
Spring对JDBC的封装？
需要导入依赖 jdbc
jcl：是Spring管理事务的封装
JCDBC：封装的jdbc的包
Spring提供了JDBC的工具类 jdbcTemplate 纯xml版
//dao层中属性 来自于jdbcTemplate包
private jdbcTemplate jt;
//xml版写法，给属性赋值 需要setter方法
public void setJt(JdbcTemplate jt){
this.jt = jt;
}
public StudentDaoImp1JDBC(){
System.out.println("Student");
}
xml中
此处是dao层对象
<bean id="dao1" class="com.etoak.student.xml.dao.StudentDaoJDBC" >
<property name="jt" ref="jd" />
</bean>
以下是JdbcTemplate 需要导入依赖spring-jdbc
<bean id="jd" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="ds"></property>
</bean>
以下是数据源 需要导入 commons-dbcp
<bean id="ds" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql://127.0.0.1:3306/et2010" />
<property name="username" value="root" />
<property name="password" value="etoak" />
<!--最大等待时间-->
<property name="maxWait" value="5000" />
<!--最大连接数-->
<property name="maxActive" value="100" />
</bean>
Spring使用JdbcTemplate 注解版
但是由于JdbcTemplate是官方提供的，所以没有办法再jar包加注解，所以存在两种方式：
第一种使用xml文件 在文件中创建JdbcTmplate和数据源的对象，dao层对象使用注解
//此处使用的是注解+xml混合模式
以下是开启包扫描 base-package表示从哪里开始扫描
<context:component-scan base-package="com.etoak.student.annotation"></context:component-scan>
<bean class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="ds"/>
</bean>
<bean id="ds" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql://127.0.0.1:3306/et2010" />
<property name="username" value="root" />
<property name="password" value="etoak" />
<!--最大等待时间-->
<property name="maxWait" value="5000" />
<!--最大连接数-->
<property name="maxActive" value="100" />
</bean>
第二种使用纯注解版 自定类 在类上加入 @Configration @ComponentScan(“从哪扫描”)
package com.etoak.student.annotation_agin.controller;
import org.apache.commons.dbcp.BasicDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import javax.sql.DataSource;
@Configuration
@ComponentScan("com.etoak.student.annotation_agin")
public class UserController {
@Bean //此注解 就代表这是一个bean对象 id就是方法名
public JdbcTemplate jt(){
JdbcTemplate jt = new JdbcTemplate();
jt.setDataSource(ds());
return jt;
}
@Bean
public DataSource ds(){
BasicDataSource ds = new BasicDataSource();
ds.setUrl("jdbc:mysql://127.0.0.1:3306/et2010");
ds.setDriverClassName("com.mysql.jdbc.Driver");
ds.setUsername("root");
ds.setPassword("etoak");
ds.setMaxActive(100);
ds.setMaxWait(5000);
return ds;
}
}
dao中：
@Autowired 根据类型获得
private JdbcTemplate jt;
如何读取纯注解的对象？
ApplicationContext cls = new AnnotationConfigApplicationContext("ETconfig.class");
关于使用JdbcTemplate
-
构造对象 提供DataSource
-
增删改 使用update
-
查询使用query
-
查询返回单个记录的
int i = jt.queryForObject(sql,new Object[]{2},Integer.class); new Object[]{2}:其实是对一个Object类型的数组进行初始化 赋了个初值2 -
查询返回一个对象的方式
String select = "select * from student where id = ?" ; Stu stu = jt.queryForObject(select,new StuMapper(),1);
-
再回顾(面试题)
1. Spring简介？
- Spring是一个实现了IOC和AOP的轻量级的、非入侵式框架
- Spring可以整合很多技术，Spring可以看成是一个开发的技术栈，Spring全家桶
- Spring可以解决各层紧密耦合问题
2. SpringIOC？
- IOC：控制反转，我们开发中的对象 由原来我们自己new 到交给IOC容器自动构造的过程 叫做控制反转
- IOC是一种设计思想，SpringIOC是IOC思想的一种具体实现
- IOC思想 使开发人员不再关注对象创建的细节问题，只需要关注如何即可。更加聚焦核心业务
3. Spring IOC 和DI的区别、联系
- IOC：控制反转 是用来构造对象的
- DI：依赖注入，是用来给对象的属性赋值的 DI依赖于IOC存在
4. SpringIOC的实现原理？
关键技术是反射
对外提供getBean方法，内部通过反射拿到传进来Class类对象，和对象名
通过getDeclaredConstructor()拿到对应的构造方法 使用newInstance方法 创建对象
反射+xml newInstance setter.invoke constructor @xx
5. Spring IOC如何使用？
-
纯xml的方式
- 在xml中配置各种
- 赋值通过bean标签中的 其实还是走的setter方法，也就是属性必须提供setter方法；
- 也可以通过带参的构造方法 进行赋值
- 获得bean，ClassPathXmlApplicationContext 返回类型BeanFactory（延时加载）==ApplicaitonContext(立即加载)==最常用
-
xml+注解混合的方式
-
在xml文件中开启包扫描<context:component-scan base-package=“扫描路径”>,之后自己写的类不需要配置
取而代之的四大注解 @Component @Controller @Service @Repository
-
xml配置文件只需要配置不是我们开发的类
-
注解方式给属性赋值 @Value @Autowired @Resource
-
获得bean ClassPathXmlApplicationContext 返回类型BeanFactory（延时加载）==ApplicaitonContext(立即加载)==最常用
-
-
纯注解的方式：
-
注意：@Configration @ComponentScan @Bean全部来自于spring-context包下 SpringBoot还会再见
-
实现一个配置类：
@Configration @ComponentScan("包扫描") public class ETconfig{ @Bean public DataSource ds(){ BasicDataSource ds = new BasicDataSource(); ds.setXXX(); ... return ds; } } -
所有我们自己写的类 还是配置四大注解
-
获得bean AnnotationConfigApplicationContext
-
注解版使用步骤
1．导包 beans+core+context+expression+aop 2．配置包扫描<context:component-scan basePackage=”” /> 3．添加注解
-
6. Spring中Bean的实例化方式？ IOC
-
无参构造方式
<bean id="dao2" class="com.etoak.student.xml.dao.StudentDaoMyBatis" /> -
带参构造方式
<bean id="per" class="com.etoak.student.entity.Person"> <constructor-arg name="email" value="email@qq.com" /> <constructor-arg name="address" value="山东省"/> </bean> -
静态工厂方式
factory-method属性直接用，就代表这个方法是一个静态方法 静态方法中存在new 对象 静态工厂方式 工厂并不会实例化 <bean id="stu1" class="com.etoak.student.factory.StudentFactory" factory-method="getStu" /> -
实力工厂方式
<!--实例工厂方法--> stu2引用工厂中的方法 只要存在引用 那么工厂就会创建对象 先创建出工厂的对象，再调用工厂中的普通方法 <bean id="f" class="com.etoak.student.factory.StudentFactory"/> <bean id="stu2" factory-bean="f" factory-method="getStu1" /> -
实现BeanFactory接口
import com.etoak.student.entity.Student; import org.springframework.beans.factory.FactoryBean; public class StudentFactoryBean implements FactoryBean { public StudentFactoryBean(){ System.out.println("构造方法执行了"); } @Override public Object getObject() throws Exception { return new Student(); } @Override public Class<?> getObjectType() { return null; } } <!--实现FactoryBean接口 可以构造复杂对象--> <bean id="stu3" class="com.etoak.student.factory.StudentFactoryBean" /> 但是要注意 中间存在非常复杂的构造对象的过程 -
注解形式
@Component 通用的注解 可以加括号 指定名字 如果不指定 默认是类名的小写 @Controller 用在控制层 @Service 用在服务层 @Repository 用在dao层
7. Spring赋值方式 依赖注入DI
-
xml 使用setter和构造方法
带参构造 <bean id="per" class="com.etoak.student.entity.Person"> <constructor-arg name="email" value="email@qq.com" /> <constructor-arg name="address" value="山东省"/> </bean> setter <bean id="sv1" class="com.etoak.student.xml.service.StudentService1"> <property name="dao1" ref="dao1"></property> <property name="dao2" ref="dao2"></property> </bean> -
注解
spring-beans包 @Autowired 默认按照类型匹配，如果一个类型存在多个，则默认按照名字匹配 @Qulifier 设置名字，和上面结合使用，设置名字之后 则一定名字匹配 javax.annotation包 @Resource 默认按照名字匹配 @Resource(name="")按照名字匹配 如果没有设置name 则对应属性的名字匹配 @Resource(type=XXX.class)按照类型匹配 首先按照类中属性名字去匹配，这是type也需要和类中属性名字一致 如果IOC容器中没有类中属性名字对应的bean，则再按照type去匹配 @Value 给普通属性 赋固定值 动态的赋值 还是需要setter方法
8. BeanFactory 和 ApplicationContext的区别？
- BeanFacotory来自于beans包，是SpringIOC容器的最基本的接口，负责配置、管理、创建bean。是Spring比较原始的接口
- BeanFacoty是延迟加载对象的，即当执行getBean方法时，才会去构造对象
- ApplicationContext继承的BeanFactory，来自context包
- ApplicationContext是立即加载，当构造ApplicationContext对象时，加载配配置文件，构造对象
- 实际开发中 ApplicationContext对web支持更好。
9. IOC容器中Bean元素的作用范围？scope属性
scope属性存在两个值
- singleton：默认IOC容器只创建一个对象，单例
- prototype：每次getBean（）都会创建一个对象
结合web容器使用的：
- request：每次请求都创建一个对象
- Session：每次会话 创建一个对象
- ApplicationContext：整个应用范围，一个对象
10. IOC容器复杂赋值？
1．List
2．Set
3．Map
4．Props
5．ref
<bean id="stu">
<property name="">
<list>
</property>
<property name="">
<set></set>
</property>
...
</bean>
11.Spring IOC容器中Bean元素的常用属性？
- id:标识
- name:与id类型 可以包含特殊字符
- class：leixing
- factory-method:实例工厂
- factory-bean：实例工厂
- lazy-init：是否延时加载，默认false(立即加载) @Lazy 这个注解只要出现 就代表延时加载
- Init-method:初始化方法，构造方法完毕，紧接着调用 init初始化 @PostConstructor
- destory-method:销毁的方法 容器销毁时调用 必须调用容器的close方法 对应的注解@PreDestroy
- Scope作用范围 对应的注解 Scope()
- 其中初始化和销毁 需要结合SpringBean的生命周期来看
12. Spring Bean的生命周期 ★★★
1、 启动spring容器,也就是创建beanFactory(bean工厂),
一般用的是beanFactory的子类applicationcontext,
applicationcontext比一般的beanFactory要多很多功能,比如aop、事件等。
通过applicationcontext加载配置文件,或者利用注解的方式扫描将bean
的配置信息加载到spring容器里面。
2、 加载之后,spring容器会将这些配置信息(java bean的信息),封装成BeanDefinition对象
BeanDefinition对象其实就是普通java对象之上再封装一层,
赋予一些spring框架需要用到的属性,比如是否单例,是否懒加载等等。
3、 然后将这些BeanDefinition对象以key为beanName,
值为BeanDefinition对象的形式存入到一个map里面,
将这个map传入到spring beanfactory去进行springBean的实例化。
4、 传入到Spring beanfactory之后,利用BeanFactoryPostProcessor接口这个扩展点
去对BeanDefinition对象进行一些属性修改。
5、 开始循环BeanDefinition对象进行springBean的实例化,springBean的实例化也就
是执行bean的构造方法(单例的Bean放入单例池中,但是此刻还未初始化),
在执行实例化的前后,可以通过InstantiationAwareBeanPostProcessor扩展点
(作用于所有bean)进行一些修改。
6、 spring bean实例化之后,就开始注入属性,
首先注入自定义的属性,比如标注@autowrite的这些属性,
再调用各种Aware接口扩展方法,注入属性(spring特有的属性),
比如BeanNameAware.setBeanName,设置Bean的ID或者Name;
7、 初始化bean,对各项属性赋初始化值,,初始化前后执行BeanPostProcessor
(作用于所有bean)扩展点方法,对bean进行修改。
初始化前后除了BeanPostProcessor扩展点还有其他的扩展点,执行顺序如下:
(1). 初始化前 postProcessBeforeInitialization()
(2). 执行构造方法之后 执行 @PostConstruct 的方法
(3). 所有属性赋初始化值之后 afterPropertiesSet()
(4). 初始化时 配置文件中指定的 init-method 方法
(5). 初始化后 postProcessAfterInitialization()
先执行BeanPostProcessor扩展点的前置方法postProcessBeforeInitialization(),
再执行bean本身的构造方法
再执行@PostConstruct标注的方法
所有属性赋值完成之后执行afterPropertiesSet()
然后执行 配置文件或注解中指定的 init-method 方法
最后执行BeanPostProcessor扩展点的后置方法postProcessAfterInitialization()
8、 此时已完成bean的初始化,在程序中就可以通过spring容器拿到这些初始化好的bean。
9、 随着容器销毁,springbean也会销毁,销毁前后也有一系列的扩展点。
销毁bean之前,执行@PreDestroy 的方法
销毁时,执行配置文件或注解中指定的 destroy-method 方法。
以上就是spring bean的整个生命周期
其实就是根据配置文件或注解信息,生成BeanDefinition,
循环BeanDefinition去实例化-》注入属性-》初始化-》销毁,在这4个阶段执行前后,
spring框架提供了一系列的扩展点。
SpringBean的各种扩展点
(1)、容器级扩展点(作用于所有bean):
BeanFactoryPostProcessor接口:
在循环初始化springbean之前,对BeanDefinition元数据做扩展处理
InstantiationAwareBeanPostProcessor接口:
在对象实例化前后扩展,作用于所有bean
BeanPostProcessor接口:
在对象初始化化前后扩展,作用于所有bean
(2)、Bean扩展点(作用于单个bean):
Aware接口:
springBean实例化并且注入自定义属性之后
InitializingBean接口:
springBean初始化时,执行构造方法结束,并且属性赋初始化值结束之后执行
DiposableBean接口:
springBean销毁之前执行。
(3)、Bean自身的方法
包括了Bean本身调用的方法
通过配置文件中<bean>的init-method和destroy-method指定的方法(或者用注解的方式)
(4)、包括了AspectJWeavingEnabler,
ConfigurationClassPostProcessor,
CustomAutowireConfigurer等等非常有用的工厂后处理器接口的方法。
工厂后处理器也是容器级的。在应用上下文装配配置文件之后立即调用。
13. 常见构造对象的注解？
- @Component：组件
- 默认再容器加载时构造对象 相当于<bean id="" class = “">
- 可以通过value属性修改id的值
- @Lazy:延时加载对象 @Lazy(value=true/false)
- @Scope:作用范围 @Scope(singleton/prototype)
- 以下的来自于javax.annotation包下
- 初始化 @PostConstructor：实例化之后执行的方法 init()
- 销毁 @PreDestroy():销毁之前执行的方法 destroy()
- @Controller:控制层
- @Service：服务层
- @Repository：dao层
14. Bean中属性赋值的配置演变？
-
手动方式
<bean id = "service" class="Xxxx"> <property name="dao" ref="dao"></property> </bean> <bean id="dao" class="XXXX"></bean> -
自动装配 不需要手动给属性赋值
<bean id="service" class="XXX" autowire="byType/byName"></bean> <bean id="dao" class="XXX"></bean> 注意：如果autowire是byType 那么dao就不需要id了 因为按照类型 setter方法 是必须提供的 -
注解自动注入属性
@Autowired @Resource @Value 不需要setter方法 直接写在属性上
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
