spring整体总结

最新推荐文章于 2023-09-06 11:18:25 发布

程序员赖子

最新推荐文章于 2023-09-06 11:18:25 发布

阅读量194

点赞数

分类专栏： spring

本文链接：https://blog.csdn.net/sdkdeveloper/article/details/115419238

版权

spring 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

文章目录

Spring整体介绍

Spring整体介绍

Spring解析和创建Bean的方式有好多，包括BeanFactory，ClassPathXmlApplicationContext，AnnotationConfigApplicationContext等等。
本文是记录Spring使用AnnotationConfigApplicationContext解析Bean并创建Bean整个过程

重点类介绍

BeanDefinitionReader
用于读取bean的配置，比如通过xml配置，注解配置
Simple interface for bean definition readers
BeanDefinitionScanner
扫描bean
detects bean candidates
BeanDefinition
一个BeanDefinition用于描述一个bean实例
A BeanDefinition describes a bean instance
BeanDefinitionRegistry
负责将BeanDefinition注册到beanDefinitionMap，对应的map是ConcurrentHashMap
Interface for registries that hold bean definitions,
BeanFactory
BeanFactory是spring提供的最顶层的核心接口，是所有bean工厂的顶层接口
The root interface for accessing a Spring bean container.
BeanFactoryPostProcessor
允许自定义修改BeanDefinition
BeanDefinitionRegistryPostProcessor
允许注册(添加)BeanDefinition
对BeanDefiniton的注册和修改
Spring提供了BeanFactoryPostProcessor，允许自定义修改BeanDefinition，也提供了BeanDefinitionRegistryPostProcessor，允许注册(添加)BeanDefinition
BeanPostProcessor
工厂的钩子用来自定义修改bean实例
Factory hook that allows for custom modification of new bean instances

生产bean的一个大概过程

BeanDefinitionReader——>BeanDefinitionScanner——>BeanDefinitionRegistry——>BeanDefinition——>BeanFactory——>实例化(反射，工厂方法)——>填充属性（@Autowired,@Value）——>初始化(init method，调用相关的Aware)——>存放到map中(单例池，一级缓存)

AutowiredAnnotationBeanPostProcessor
BeanPostProcessor的实现

Bean生命周期的后置处理器

调试源码

public class Test {

  public static void main(String[] args) {
    ApplicationContext context = new AnnotationConfigApplicationContext(MyBean.class);
    Book book = context.getBean(Book.class);
    book.printBookName();
  }
}

@Configuration
public class MyBean {

  @Bean
  public Book book() {
    return new Book();
  }
}

public class Book {

  public void printBookName(){
    System.out.println("Spring in action");
  }
}

AnnotationConfigApplicationContext类图

进入AnnotationConfigApplicationContext的构造方法，主要包含三个方法

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
		this();
		register(annotatedClasses);
		refresh();
	}

在说明this()方法执行的过程之前，有必要对Spring中一些重要的类进行说明：
DefaultListableBeanFactory:是整个bean加载的核心，是Spring注册及加载bean的默认实现
在这里插入图片描述

BeanDefinitionRegistry：定义对BeanDefinition的各种增删改操作，本质是操作map，key是beanName
ConfigurableListableBeanFactory：是BeanFactory的配置清单，指定忽略类型及接口等

this()方法执行过程一些重要步骤
this方法调用父类GenericApplicationContext构造方法和自身构造方法初始化相关类，父类构造方法将DefaultListableBeanFactory初始化

public GenericApplicationContext() {
		this.beanFactory = new DefaultListableBeanFactory();
	}

自身类的构造方法初始化AnnotatedBeanDefinitionReader和ClassPathBeanDefinitionScanner

public AnnotationConfigApplicationContext() {
	this.reader = new AnnotatedBeanDefinitionReader(this);
	this.scanner = new ClassPathBeanDefinitionScanner(this);
}

在初始化AnnotatedBeanDefinitionReader时调用自身构造方法注册很多处理器，这些处理器都是用于处理相应的注解的。

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
		this(registry, getOrCreateEnvironment(registry));
	}

处理器最终注册方法入口org.springframework.context.annotation.AnnotationConfigUtils#registerAnnotationConfigProcessors(org.springframework.beans.factory.support.BeanDefinitionRegistry, java.lang.Object)
注册的处理器

	/**
	 * The bean name of the internally managed Configuration annotation processor.
	 */
	public static final String CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME =
			"org.springframework.context.annotation.internalConfigurationAnnotationProcessor";

	/**
	 * The bean name of the internally managed BeanNameGenerator for use when processing
	 * {@link Configuration} classes. Set by {@link AnnotationConfigApplicationContext}
	 * and {@code AnnotationConfigWebApplicationContext} during bootstrap in order to make
	 * any custom name generation strategy available to the underlying
	 * {@link ConfigurationClassPostProcessor}.
	 * @since 3.1.1
	 */
	public static final String CONFIGURATION_BEAN_NAME_GENERATOR =
			"org.springframework.context.annotation.internalConfigurationBeanNameGenerator";

	/**
	 * The bean name of the internally managed Autowired annotation processor.
	 */
	public static final String AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME =
			"org.springframework.context.annotation.internalAutowiredAnnotationProcessor";

	/**
	 * The bean name of the internally managed Required annotation processor.
	 */
	public static final String REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME =
			"org.springframework.context.annotation.internalRequiredAnnotationProcessor";

	/**
	 * The bean name of the internally managed JSR-250 annotation processor.
	 */
	public static final String COMMON_ANNOTATION_PROCESSOR_BEAN_NAME =
			"org.springframework.context.annotation.internalCommonAnnotationProcessor";

	/**
	 * The bean name of the internally managed JPA annotation processor.
	 */
	public static final String PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME =
			"org.springframework.context.annotation.internalPersistenceAnnotationProcessor";


	private static final String PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME =
			"org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor";

	/**
	 * The bean name of the internally managed @EventListener annotation processor.
	 */
	public static final String EVENT_LISTENER_PROCESSOR_BEAN_NAME =
			"org.springframework.context.event.internalEventListenerProcessor";

register()方法主要是将BeanDefinition注册到map中
refresh方法
refresh()方法包含了Application中提供的几乎全部功能，是整个IOC生命周期的体现。

public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// 第一步：Prepare this context for refreshing.
			prepareRefresh();

			// 第二步：Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// 第三步：Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {
				// 第四步：Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				// 第五步：Invoke factory processors registered as beans in the context.
				// 调用前文提到的各种处理器将配置解析成BeanDefinition
				invokeBeanFactoryPostProcessors(beanFactory);

				// 第六步：Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);

				// 第七步：Initialize message source for this context.
				initMessageSource();

				// 第八步：Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				// 第九步：Initialize other special beans in specific context subclasses.
				onRefresh();

				// 第十步：Check for listener beans and register them.
				registerListeners();

				// 第十一步：Instantiate all remaining (non-lazy-init) singletons.
				// 初始化剩下的单实例(非懒加载的)
				finishBeanFactoryInitialization(beanFactory);

				// 第十二步：Last step: publish corresponding event.
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

在对refresh说明时，需要对一些前提只是预热：

spring转换成bean的过程：注解，xml配置 ——>BeanDefinition——>bean
BeanFactoryPostProcessor:

/**
*允许自定义修改容器的BeanDefinition
*/
public interface BeanFactoryPostProcessor {
	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;

}

BeanDefinitionRegistryPostProcessor

/**
*是spring提供的SPI接口，用于注册BeanDifinition
 * Extension to the standard {@link BeanFactoryPostProcessor} SPI, allowing for
 * the registration of further bean definitions <i>before</i> regular
 * BeanFactoryPostProcessor detection kicks in. In particular,
 * BeanDefinitionRegistryPostProcessor may register further bean definitions
 * which in turn define BeanFactoryPostProcessor instances.
*/
public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
	void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;

}

第五步：调用前文提到的各种处理器将配置解析成BeanDefinition，主要分成两步

调用所有实现BeanDefinitionRegistryPostProcessors的子类
调用所有实现BeanFactoryPostProcessors的子类

解析BeanDifinition

public void parse(Set<BeanDefinitionHolder> configCandidates) {
		this.deferredImportSelectors = new LinkedList<DeferredImportSelectorHolder>();

		for (BeanDefinitionHolder holder : configCandidates) {
			BeanDefinition bd = holder.getBeanDefinition();
			try {
				if (bd instanceof AnnotatedBeanDefinition) {
					parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
				}
				else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
					parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
				}
				else {
					parse(bd.getBeanClassName(), holder.getBeanName());
				}
			}
			catch (BeanDefinitionStoreException ex) {
				throw ex;
			}
			catch (Throwable ex) {
				throw new BeanDefinitionStoreException(
						"Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
			}
		}

		processDeferredImportSelectors();
	}

第十一步：冻结BeanDefinition的修改，将所有非懒加载的单例Bean创建出来
这里有一步isFactoryBean(beanName),··是用于判断是不是实现了FactoryBean进行自定义bean
循环依赖解决办法

spring使用了三级缓存解决循环依赖，所有单例的bean初始化完成后会存放在一个singletonObjects，.二三级缓存就是为了解决循环依赖，且之所以是二三级缓存而不是二级缓存，主要是可以解决循环依赖对象需要提前被aop代理，以及如果没有循环依赖，早期的bean也不会真正暴露，不用执行无用的代理过程，也不用重复执行代理过程

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
/** Cache of singleton objects: bean name --> bean instance */
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);

	/** Cache of singleton factories: bean name --> ObjectFactory */
	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);

	/** Cache of early singleton objects: bean name --> bean instance */
	private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);
。。。
}

一个简单实现用来说明循环依赖的解决办法

public static void main(String[] args) throws Exception {
        ApplicationContext context = new AnnotationConfigApplicationContext(MyBean.class);
        Book book = context.getBean(Book.class);
        book.printBookName();


        loadBeanDefinitions();
        A a = (A) getBean("a");
        B b = (B) getBean("b");
        a.print();
        b.print();
    }

    private static Object getBean(String beanName) throws Exception {
        Object singleton = getSingleton(beanName);
        if (singleton != null) {
            return singleton;
        }
        RootBeanDefinition beanDefinition = (RootBeanDefinition) beanDefinitionMap.get(beanName);
        Class<?> beanClass = beanDefinition.getBeanClass();
        Object instance = beanClass.newInstance();
        // 添加到一级缓存
        singletonObject.put(beanName, instance);
        Field[] declaredField = beanClass.getDeclaredFields();
        for (Field field : declaredField) {
            if (field.getAnnotation(Autowired.class) != null) {
                field.setAccessible(true);
                Object bean = getBean(field.getName());
                field.set(instance, bean);
            }
        }
        // 初始化
        return instance;
    }

    private static void loadBeanDefinitions() {
        BeanDefinition beanDefinitionA = new RootBeanDefinition(A.class);
        BeanDefinition beanDefinitionB = new RootBeanDefinition(B.class);
        beanDefinitionMap.put("a", beanDefinitionA);
        beanDefinitionMap.put("b", beanDefinitionB);
    }

    public static Object getSingleton(String beanName) {
        if (singletonObject.containsKey(beanName)) {
            return singletonObject.get(beanName);
        }
        return null;
    }

spring监听器

内置监听器

@Component
public class ContextRefreshEvent {

    @EventListener(ContextRefreshedEvent.class)
    public void onContextRefreshedEvent(){
        System.out.println("容器加载完毕");
    }
}

监听者模式三大核心：事件，监听器，事件发布器，对于自定义事件，还是用谷歌开源的guava吧

spring事务

-使用@EnableTransactionManagement开启事务


@EnableTransactionManagement
@Configuration
@ComponentScan(value = "xxx")
public class TransactionConfig {

    @Bean
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        dataSource.setUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        return dataSource;
    }


    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }

    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }


}

使用@Transactional声明事务


	@Transactional(rollbackFor = Exception.class)
    public void pay(int accountId, double money) {
       // 业务逻辑
        System.out.println(1/0);

    }

使用spirng的事务很简单，通过注解两步就完成

默认情况下，如果一个方法调用同一个service中的方法，那么是不会生效的，可以使用**AopContext.currentProxy())**获取当前代理类，这样就会生效了。

@Transactional(rollbackFor = Exception.class)
    public void pay(int accountId, double money) {
       // 业务逻辑

        Service update = ((Service) AopContext.currentProxy()).update();
        System.out.println(1/0);
    }
   
     /**
     * DEFAULT(-1), // spring默认使用数据库的隔离级别
     * READ_UNCOMMITTED(1),
     * READ_COMMITTED(2),
     * REPEATABLE_READ(4),
     * SERIALIZABLE(8);
     * 
     * 
     * REQUIRED(0), //默认
     * SUPPORTS(1),
     * MANDATORY(2),
     * REQUIRES_NEW(3),
     * NOT_SUPPORTED(4),
     * NEVER(5),
     * NESTED(6);
     *
     * @return
     */
    @Transactional(isolation = Isolation.REPEATABLE_READ,propagation = Propagation.REQUIRED)
    public Service update() {
        // 业务逻辑
        return null;
    }

一些spirng文章参考：
spring事务传播机制
 spring事务实现原理

程序员赖子

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
spring整体总结

Spring解析和创建Bean的方式有好多，包括BeanFactory，XmlClassPathXmlApplicationContext，AnnotationConfigApplicationContext等等。本文是记录Spring使用AnnotationConfigApplicationContext解析Bean并创建Bean整个过程
复制链接

扫一扫

专栏目录