Spring框架总结

Posted 2022-11-30 You295

Spring框架总结

• 一：spring框架简介以及核心
• 二：开发流程
• 三：spring bean的生命周期
• 四：注解-释意
• 五：常见问题

一：spring框架简介以及核心

Spring框架是一个开放源代码的JavaEE应用程序框架，由Rod Johnson发起，是针对bean的生命周期进行管理的轻量级容器（lightweight container）。
Spring解决了开发者在JavaEE开发中遇到的许多常见的问题，提供了功能强大IOC、AOP及Web MVC等功能。
Spring可以单独应用于构筑应用程序，也可以和Struts、Webwork、Tapestry等众多Web框架组合使用，并且可以与 Swing等桌面应用程序AP组合。因此， Spring不仅仅能应用于JavaEE应用程序之中，也可以应用于桌面应用程序以及小应用程序之中。

总结：1. javaee（SE）的开源框架
2. 设计上： 软件解耦，解除（降低）对象对象的依赖
3. 软件设计：超级工厂（创建对象，注入对象，管理对象等）
4. 应用：与各大框架的整合技术（hibernate，struts2–>ssh, mybatis–>SSM)

核心：
1.loc：即控制反转。举例：在之前的操作中，假设在一个类中，我们想要调用类中的方法（不是静态方法），就要创建该类的对象，使用对象调用方法来实现。但是对于spring中，spring创建对象的过程，没有在代码中实现，而是交给spring来进行配置进行的。
2.AOP：面向切面编程。

二：开发流程

1.引入依赖
根据此图进行引入：

引入代码：

<dependencies>
      //必须引入
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>5.3.9</version>
		</dependency>
      //测试
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<scope>test</scope>
		</dependency>

       
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<version>1.18.20</version>
		</dependency>
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>1.2.17</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>1.7.32</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>1.7.32</version>
		</dependency>
	</dependencies>

2.创建实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Book 
	
	private Integer id;
	private String title;
	private String author;
	private Double price;

3.定义spring中管理的内容，配置文件applicationContext.xml
：id/name:唯一名称 ； class: 类全名；property: 对象的属性(set 方法)

<?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="myBook" class="com.dyit.spring.entity.Book">
		<property name="id" value="001" />
		<property name="title" value="西游记" />
		<property name="author" value="吴承恩" />
		<property name="price" value="33.33" />
	</bean>
</beans>

Bean配置信息定义了Bean的实现及依赖关系，Spring容器根据各种形式的Bean配置信息在容器内部建立Bean定义注册表，然后根据注册表加载、实例化Bean，并建立Bean和Bean的依赖关系，最后将这些准备就绪的Bean放到Bean缓存池中，以供外层的应用程序进行调用。
4.创建spring容器

//配置路径
final String CONFIG_LOCATION = "classpath:spring/applicationContext.xml";
//创建spring工厂(容器)
		ApplicationContext factory=
				new FileSystemXmlApplicationContext(CONFIG_LOCATION);

5.读取Bean（组件、对象）

Book book = factory.getBean("myBook", Book.class);

6.运行

三：spring bean的生命周期

1.Spring启动，查找并加载需要被Spring管理的bean，进行Bean的实例化。
2.Bean实例化后对将Bean的引入和值注入到Bean的属性中。
3.如果Bean实现了BeanNameAware接口的话，Spring将Bean的Id传递给setBeanName()方法。
4.如果Bean实现了BeanFactoryAware接口的话，Spring将调用。setBeanFactory()方法，将BeanFactory容器实例传入。
5.如果Bean实现了ApplicationContextAware接口的话，Spring将调用Bean的setApplicationContext()方法，将bean所在应用上下文引用传入进来。
6.如果Bean实现了BeanPostProcessor接口，Spring就将调用他们的postProcessBeforeInitialization()方法。
7.如果Bean 实现了InitializingBean接口，Spring将调用他们的afterPropertiesSet()方法。类似的，如果bean使用init-method声明了初始化方法，该方法也会被调用。
8.如果Bean 实现了BeanPostProcessor接口，Spring就将调用他们的postProcessAfterInitialization()方法。
9.此时，Bean已经准备就绪，可以被应用程序使用了。他们将一直驻留在应用上下文中，直到应用上下文被销毁。
10.如果bean实现了DisposableBean接口，Spring将调用它的destory()接口方法，同样，如果bean使用了destory-method 声明销毁方法，该方法也会被调用。

四：注解-释意

1.加载注解：

<context:component-scan base-package="com.dyit.spring.entity"/>

2.@Component 当前类是容器中的组件
@Controller -->控制层
@Service —》service
@Repository—> mapper/dao

含义： 扫描 com.dyit.spring.entity文件夹下的所有类，如果有@Compoent,@Controller,@Service,@Repository注解的类将其创建对象放入容器中备用。

4.@Configuration
使用配置类替代appliationContext.xml

@Configuration
public class HelloConfiguration 
	
	@Bean(name = "b3")
	public Book3 book3() 
		return new Book3();
	


//测试
	ApplicationContext factory =new AnnotationConfigApplicationContext("com.dyit.spring.config");
		Book3 b3 =factory.getBean("b3", Book3.class);
		System.out.println(b3);

5.属性：

prototype: 原生态, 不由spring IoC容器管理
request: 一个请求
session： 会话周期
singleton：单例，存在于容器

问题
如何判断对象是有状态的？
有状态：对象中持有（可存储）数据，由多个线程可以共享，对象(持有其它属性，属性的可以改变的)，线程的不安全
无状态的对象： Dao Mapper

五：常见问题

1.spring中用到了那些设计模式？

1）单例模式：spring中的bean在默认情况下都是单例的。
2）工厂模式：主要通过对BeanFactory和ApplicationContext来生产bean对象。
3）代理模式：最常见的AOP的实现方式就是通过代理来实现的，spring主要是使用JDK动态代理和CGLIB代理。
4）模板方法模式：只要在一些对数据库的操作类中用到，比如：JdbcTemplate，JpaTemplate，因为数据库的建立连接，执行查询，关闭连接几个过程中，非常适合用模板方法。

2.对loc和Aop的理解？以及他们的实现原理？

1）loc叫做控制反转，就是通过spring来管理对象的创建，配置，生命周期。相当于将对对象的控制权交给了spring，就不需要人工来管理对象之间的复杂关系，好处就是解耦。spring中主要提供了两种loc容器，分别是：BeanFactory和ApplicationContext，通过他们来实现对Bean的管理。

2）AOP叫做面向切面编程，是一个编程范式，目的是提高代码的模块性。Spring AOP基于动态代理的方式实现，如果是实现了接口的话就会使用jdk动态代理，反之则会使用CGLIB代理，aop中的应用主要体现在 事务.日志 .异常处理等的方面。通过在代码的前后做一些增强处理，可以实现对业务逻辑的隔离，提高代码的模块化能力，同时也是解耦。spring主要提供了Aspect切面，JoinPoint连接点，PointCut切入点，Advice增强等的实现方式。

3.JDK动态代理和CGLIB代理有什么区别

1）JDK动态代理主要是针对实现某个接口，AOP则会使用jdk动态代理。他是基于反射的机制实现，生成一个实现同样接口的代理类，然后通过重写方法的方式，实现对代码的增强。

2）而如果某个类没有实现接口，AOP则会使用CGLIB代理。它的底层原理是基于asm第三方框架，通过修改字节码生成一个子类，然后重写父类的方法。实现对代码的增强。

4.BeanFactory和FactoryBean有什么区别？

1）BeanFactory是Bean的工厂，ApplicationContext的父类，是Loc的核心，负责生产和管理bean对象。

2）FactoryBean是Bean，可以通过实现FactoryBean接口定制实例化Bean的逻辑，通过代理一个Bean对象，对方法的前后做出一些操作。

5.SpringBoot的启动流程

1）准备环境，根据不同的环境创建不同的Environment
2）准备，加载上下文，为不同的环境选择不同的SpringContext，然后加载资源，配置Bean
3）初始化，刷新SpringContext，启动应用。
4）流程结束。