Spring 复习

Spring框架有哪些主要模块

Spring大约18个基本模块,大致分为4类;分别是核心模块、AOP、数据访问、Web模块、测试模块。

核心模块:core beans context context-support expression(SpLE)

AOP模块包括:aop、aspects、instrument共3个模块;

数据访问模块包括:jdbc、tx、orm、oxm共4个模块;

Web模块包括:web、webmvc、websocket、webflux共4个模块;

集成测试模块:test模块。

SpLE: Spring Language Expression

https://www.jianshu.com/p/807d4fa7978b

什么是控制反转(IOC)?什么是依赖注入?

Inversion of Control

Ioc 意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制。

传统Java程序设计,直接在对象内部通过new进行创建对象,是程序主动去创建依赖对象;而IoC是通过一个容器来创建这些对象,即由Ioc容器来控制对象的创建,并通过依赖注入的的方式注入其依赖的对象,容器主要控制了外部资源获取(不只是对象包括比如文件等)。

松耦合 ,有了IoC容器后,把创建和查找依赖对象的控制权交给了容器,由容器进行注入组合对象,所以对象与对象之间是 松散耦合,这样也方便测试,利于功能复用,更重要的是使得程序的整个体系结构变得非常灵活。

对于spring框架来说,就是由spring来负责控制对象的生命周期和对象间的关系。

BeanFactory和ApplicationContext有什么区别?

区别

BeanFactory 可以理解为含有Bean集合的工厂类。BeanFactory 包含了bean的定义,以便在接收到客户端请求时将对应的Bean实例化。

BeanFactory还能在实例化对象时生成协作类之间的关系。此举将Bean自身从Bean客户端的配置中解放出来。BeanFactory还包含Bean生命周期的控制,调用客户端的初始化方法(initialization Methods)和销毁方法(destruction Methods)。

从表面上看,ApplicationContext如同Bean Factory一样具有Bean定义、Bean关联关系的设置,以及根据请求分发Bean的功能。但ApplicationContext在此基础上还提供了其他功能。 

  • (1)提供了支持国际化的文本消息。
  • (2)统一的资源文件读取方式。
  • (3)已在监听器中注册的Bean的事件。

以下是三种较常见的 ApplicationContext 实现方式。

  • (1)ClassPathXmlApplicationContext:从classpath的XML配置文件中读取上下文,并生成上下文定义。应用程序上下文从程序环境变量中取得。 ApplicationContext context = new ClassPathXmlApplicationContext(“application.xml”); 
  • (2)FileSystemXmlApplicationContext :由文件系统中的XML配置文件读取上下文。 
  • ApplicationContext context = new FileSystemXmlApplicationContext(“application.xml”); 
  • (3)XmlWebApplicationContext:由Web应用的XML文件读取上下文。

JMS( JavaMessageService  ): 异步消息机制及Spring对JMS封装

broker

点对点(point-to-point)模式 queue

发布/订阅(pub/subscribe)模式 Topic

https://blog.csdn.net/suifeng3051/article/details/51718675

https://blog.csdn.net/suifeng3051/article/details/51721141 activeMQ实例

@Scheduled

https://www.jianshu.com/p/1defb0f22ed1

cron表达式生成: https://cron.qqe2.com/

org.springframework.scheduling.annotation.SchedulingConfiguration 用以配置 Scheduling ,启动的时候生成一个ScheduledAnnotationBeanPostProcessor的Bean实例 ;

ScheduledAnnotationBeanPostProcessor 实现了BeanPostProcesser的postProcessAfterInitialization方法,会被注册到PostPrecesser中,每次bean初始化的时候走一遍下面这个代码,解析@Scheduled中的值,获取定时信息。

@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) {
		if (bean instanceof AopInfrastructureBean || bean instanceof TaskScheduler ||
				bean instanceof ScheduledExecutorService) {
			// Ignore AOP infrastructure such as scoped proxies.
			return bean;
		}

		Class<?> targetClass = AopProxyUtils.ultimateTargetClass(bean);
		if (!this.nonAnnotatedClasses.contains(targetClass)) {
			Map<Method, Set<Scheduled>> annotatedMethods = MethodIntrospector.selectMethods(targetClass,
					(MethodIntrospector.MetadataLookup<Set<Scheduled>>) method -> {
						Set<Scheduled> scheduledMethods = AnnotatedElementUtils.getMergedRepeatableAnnotations(
								method, Scheduled.class, Schedules.class);
						return (!scheduledMethods.isEmpty() ? scheduledMethods : null);
					});
			if (annotatedMethods.isEmpty()) {
				this.nonAnnotatedClasses.add(targetClass);
				if (logger.isTraceEnabled()) {
					logger.trace("No @Scheduled annotations found on bean class: " + targetClass);
				}
			}
			else {
				// Non-empty set of methods
				annotatedMethods.forEach((method, scheduledMethods) ->
						scheduledMethods.forEach(scheduled -> processScheduled(scheduled, method, bean)));
				if (logger.isTraceEnabled()) {
					logger.trace(annotatedMethods.size() + " @Scheduled methods processed on bean '" + beanName +
							"': " + annotatedMethods);
				}
			}
		}
		return bean;

Converter

/**
 * A converter converts a source object of type {@code S} to a target of type {@code T}.
 *
 * <p>Implementations of this interface are thread-safe and can be shared.
 *
 * <p>Implementations may additionally implement {@link ConditionalConverter}.
 *
 * @author Keith Donald
 * @since 3.0
 * @param <S> the source type
 * @param <T> the target type
 */
@FunctionalInterface
public interface Converter<S, T> {

	/**
	 * Convert the source object of type {@code S} to target type {@code T}.
	 * @param source the source object to convert, which must be an instance of {@code S} (never {@code null})
	 * @return the converted object, which must be an instance of {@code T} (potentially {@code null})
	 * @throws IllegalArgumentException if the source cannot be converted to the desired target type
	 */
	@Nullable
	T convert(S source);

}

Aware

解释

A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method. The actual method signature is determined by individual subinterfaces but should typically consist of just one void-returning method that accepts a single argument.

Note that merely implementing {@link Aware} provides no default functionality. Rather, processing must be done explicitly, for example in a {@link org.springframework.beans.factory.config.BeanPostProcessor}. Refer to {@link org.springframework.context.support.ApplicationContextAwareProcessor} for an example of processing specific {@code Aware} interface callbacks.

一个标记超接口,指示bean有资格通过回调样式的方法被特定框架对象的Spring容器通知。实际的方法签名由单个子接口确定,但通常只应包含一个接受单个参数的void返回方法。

注意,仅仅实现{@link Aware}没有提供默认功能。相反,处理必须显式地完成,例如在{@link org.springframework.bean.factory.config. beanpostprocessor}中。请参考{@link org.springframework.context.support。一个处理特定{@code Aware}接口回调的例子。

例如:实现 ApplicationContextAware 接口的Bean

由 ApplicationContextAwareProcessor 来处理,而 ApplicationContextAwareProcessor 实现了 BeanPostProcessor 。所以实现ApplicationContextAware的方法最终都由 BeanFactory在Bean初始化时在BeanPostProcessor 步骤时 处理。

  • AbstractApplicationContext在BeanFactory的BeanPostProcessor添加ApplicationContextAwareProcessor实例,beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
  • AbstractAutowireCapableBeanFactory在初始化Bean的时候( 也就是调用initializeBean )调用applyBeanPostProcessorsBeforeInitialization把ApplicationContext 注入到对应的Bean中。

初始化Bean

Listener CompositeListener

一般编写一个Listener 的时候,如果一次要处理多个不同事情,也就是多个监听器共同处理,就可以写一个CompositeListener,在监听方法中遍历调用所有监听器监听方法。

Spring事件监听 ApplicationEvent @EventListener

两个重要的东西:ApplicationEvent 和 @EventListener。

  • 通过继承 ApplicationEvent 作为一个事件类;
  • 通过 @EventListener 注解一个方法(如:
    @EventListener
    public void onGetOrderCheckIntoResultEvent(CheckIntoResultEvent event)

    ) 作为响应监听后执行的代码。
  • 通过applicationContext.publishEvent(event); 将该应用程序事件通知在此应用程序中注册的所有匹配的侦听器。 applicationContext 可以通过实现 ApplicationContextAware接口获得。





除非注明,否则均为一叶呼呼原创文章,转载必须以链接形式标明本文链接

本文链接:http://www.yiyehu.tech/archives/2020/05/19/spring-review

发表评论

电子邮件地址不会被公开。 必填项已用*标注