1. Spring加载Bean流程解析
spring的bean生命周期其实最核心的分为4个步骤，只要理清三个关键的步骤，其他的只是在这三个细节中添加不同的细节实现,也就是spring的bean生命周期:
-.();
这个阶段允许在Bena进行实例化之前，允许开发者自定义逻辑，如返回一个代理对象。不过需要注意的是假如在这个阶段返回了一个不为null的实例，spring就会中断后续的过程。
-BeanPostProcessor.postProcessAfterInstantiation();
这个阶段是Bean实例化完毕后执行的后处理操作，所有在初始化逻辑、装配逻辑之前执行
该方法在bean初始化方法前被调用，Spring AOP的底层处理也是通过实现BeanPostProcessor来执行代理逻辑的
自定义属性值 该方法允许我们进行对对象中的属性进行设置，假如在某些业务中，一个对象的某些属性为null,但是不能显示为null，比如显示0或者其他的固定数值，我们就可以在这个方法实现中将null值转换为特定的值
可以在这个方法中进行bean的实例化之后的处理，比如我们的自定义注解，对依赖对象的版本控制自动路由切换。比如有一个服务依赖了两种版本的实现，我们如何实现自动切换呢？这时候可以自定义一个路由注解,假如叫@RouteAnnotaion，然后实现BeanPostProcessor接口，在其中通过反射拿到自定义的注解@RouteAnnotaion再进行路由规则的设定。
容器正式渲染完毕，开始启动阶段,bean已经在spring容器的管理下,程序可以随时调用
spring会将所有的bean销毁,实现的bean实例被销毁的时候释放资源被调用
2. spring基于注解的普通类怎么调用@Services注解的service方法
1、添加util方法：
package com.hzc.util;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
/**
* 普通类调用Spring注解方式的Service层bean
* Created by HZC on 2015/10/21.
*/
public class SpringBeanFactoryUtils implements ApplicationContextAware {
private static ApplicationContext appCtx;
/**
* 此方法可以把ApplicationContext对象inject到当前类中作为一个静态成员变量。
*
* @param applicationContext ApplicationContext 对象.
* @throws BeansException
* @author hzc
*/
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
appCtx = applicationContext;
}
/**
* 获取ApplicationContext
*
* @return
* @author hzc
*/
public static ApplicationContext getApplicationContext() {
return appCtx;
}
/**
* 这是一个便利的方法，帮助我们快速得到一个BEAN
*
* @param beanName bean的名字
* @return 返回一个bean对象
* @author hzc
*/
public static Object getBean(String beanName) {
return appCtx.getBean(beanName);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
2、在spring的配置文件.xml中添加
<bean id="springBeanFactoryUtils" class="com.haier.util.SpringBeanFactoryUtils"/>
1
1
3、service方法
package com.hzc.service.impl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
/**
* Created by HZC on 2015/10/20.
*/
@Service("ckPayoffService")
public class CKPayoffServiceImpl implements ICKPayoffOrderService {
private static final Logger log = LoggerFactory.getLogger(CKPayoffServiceImpl.class);
/**
* 测试
*
* @author HZC
* @createDate 2015-10-21
*/
@Override
@Transactional
public void calculatePayoff() {
System.out.println("--------------------------gogogogogo---------------");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
4、使用
CKPayoffServiceImpl ckps = (CKPayoffServiceImpl) SpringBeanFactoryUtils.getBean("ckPayoffService");
ckps.calculatePayoff();
1
2
1
2
在普通类中就可以调用service实例方法了，执行calculatePayoff方法，打印“————————–gogogogogo—————”
3. spring注入bean，怎么直接调用其方法
一般需要在static方法里调用注入进来的service，因为是静态方法，所以必须声明该service也必须是static的，这时候你会发现注入不进来，会报null指针，这个时候需要使用 @PostConstruct来解决。
4. 注解bean的用途
1、@Component注解表明一个类会作为组件类，并告知Spring要为这个类创建bean。
2、@Bean注解告诉Spring这个方法将会返回一个对象，这个对象要注册为Spring应用上下文中的bean。通常方法体中包含了最终产生bean实例的逻辑。
两者的目的是一样的，都是注册bean到Spring容器中。
区别：
@Component（@Controller、@Service、@Repository）通常是通过类路径扫描来自动侦测以及自动装配到Spring容器中。
而@Bean注解通常是我们在标有该注解的方法中定义产生这个bean的逻辑。
@Component 作用于类，@Bean作用于方法。
总结：
@Component和@Bean都是用来注册Bean并装配到Spring容器中，但是Bean比Component的自定义性更强。可以实现一些Component实现不了的自定义加载类。
5. Spring之Bean
spring 容器就是一个工厂，而bean 是工厂里的每一个产品，而这个工厂生产什么样的产品，是依赖于配置文件的声明。
一、
注册的方式有两种：
1、xml配置文件
2、java based 配置
二、Bean的命名规则
默认，spring是以@Bean声明的方法名作为bean的名称，spring容器集中管理Bean的实例化，Bean实例可以通过BeanFactory的getBean(string beanName) 方法得到。
从上图可以看出，
name:用于为bean指定别名，如果需要为Bean实例指定多个别名，可以在name 属性中使用逗号，冒号和空格来分隔多个别名
autowire:是否按名称或是类型来注入依赖的对象
initMethod: 在初始化完后，调用的方法
destroyMethod: bean在销毁时调用的方法
三、Bean的作用域
通过@Scope来声明
1、singleton:单例模式
2、Prototype:原型模式
3、request:对于 每次http 请求，bean都会产生一个新的实例，只有在web 应用中才会生效
4、session 对于 每次HttpSession时会产生一个新的实例，只有在web 应用中才会生效
5、global session ,只有在portlet context中有效
比较常用到的是singleton和prototype，java在创建实例，要进行内存申请，销毁实例时，要垃圾回收，这些都会导致系统开销的增加，因此prototype作用域的bean在创建、销毁代价会比较大，而singleton的bean实例，一旦创建，就可以重复使用
四、Bean的生命周期
1、@Bean注解的内容：通过配置initMethod和destroyMethod方法
2、bean的接口：BeanNameAware、BeanFactoryAware、InitializingBean和DiposableBean这些接口，@PostConstruct,@PreDestroy
测试如下
bean的声明：
日志输出：
我们来看下Bean的初始化是怎么进行的
1、是调用 实现了相应Aware接口的方法
2、调用Bean实例的后置处理器BeanPostProcessor
这里有两个方法 ，Before和After....,分别在initMethod方法前后被调用
3、调用Bean实例的InitializingBean接口和@Bean的initMethod，InitializingBean接口是优于initMethod的
4、实例销毁