Spring
1. 初识Spring
2. 为什么要引入Spring
在spring之前,我们的代码
3. Spring核心概念
3.1 IOC**(Inversion of Control)**控制反转
3.1.1 控制反转是什么
IOC**(控制反转)是一种思想**,使用对象时,由主动new产生对象转换为由外部提供对象,此过程中对象创建控制权由程序转移到外部,此思想称为控制反转。
3.1.2 Spring和IOC的关系
Spring对IOC进行了实现,Spring提供了一个容器,称为IOC容器,用来充当IOC思想中的外部,IOC思想中的别人[外部]指的就是Spring的IOC容器。
3.1.3 IOC的作用以及内部存放的是什么
IOC容器负责对象的创建、初始化等一系列工作,其中包含了数据层和业务层的类对象
被创建或被管理的对象在IOC容器中统称为Bean ,IOC容器中放的就是一个个的Bean对象
3.1.4 当IOC容器创建好了service和dao对象后,程序就能正常运行吗
不行,因为service运行需要依赖dao对象 ,IOC容器中虽然有service和dao对象 ,但是service对象和dao对象没有任何关系 ,需要把dao对象交给service,也就是说要绑定service和dao对象之间的关系
这就是我们所说的依赖注入
3.2依赖注入
在容器中建立bean与bean之间的依赖关系的整个过程,称为依赖注入
业务层要用数据层的类对象,以前是自己new的
现在自己不new了,靠别人[外部其实指的就是IOC容器]来给注入进来
这种思想就是依赖注入
3.3 AOP 面向切面编程
4 IOC
4.1 BeanFactory快速入门
(1)导入Spring的jar包或Maven坐标
<!--Spring核心-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.7</version>
</dependency>
(2)定义UserService接口及其UserServiceImpl 实现类
public interface UserService {}
public class UserServiceImpl implements UserService {}
(3)创建beans.xml配置文件,将UserServiceImpl的信息配置到该xml中
bean id="userService" class="com.itheima.service.impl.UserServiceImpl"></bean>
(4)编写测试代码,创建BeanFactory,加载配置文件,获取UserService实例对象
//创建BeanFactory
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();//创建读取器
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);//加载配置文件
reader.loadBeanDefinitions("beans.xml");
//获取Bean实例对象
UserDao userService= (UserService) beanFactory.getBean("userService");
上面使用BeanFactory完成了IoC思想的实现,下面去实现以下DI依赖注入:
1)定义UserDao接口及其UserDaoImpl实现类;
public interface UserDao {}
public class UserDaoImpl implements UserDao {}
2)修改UserServiceImpl代码,添加一个setUserDao(UserDaouserDao)用于接收注入的对象;
public class UserServiceImpl implements UserService {
private UserDao userDao;
public void setUserDao(UserDao userDao) {
System.out.println("执行DI 注入userDao");
this.userDao = userDao;
System.out.println("userDao:"+userDao);
}
}
3)修改beans.xml配置文件,在UserDaoImpl的中嵌入配置注入;
<?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="userService" class="com.tyust.service.impl.UserServiceImpl">
<property name="userDao" ref="userDao"></property>
</bean>
<bean id="userDao" class="com.tyust.dao.impl.UserDaoImpl"></bean>
</beans>
4)修改测试代码,获得UserService时,setUserService方法执行了注入操作。
public class test01 {
public static void main(String[] args) {
//bean工厂
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
//创建读取器
XmlBeanDefinitionReader reeder = new XmlBeanDefinitionReader(beanFactory);
//读取xml
reeder.loadBeanDefinitions("beans.xml");
//获取bean
UserService userService = (UserService)beanFactory.getBean("userService");
System.out.println("userService"+userService);
}
}
4.2ApplicationContext快速入门
ApplicationContext称为Spring容器,内部封装了BeanFactory,比BeanFactory功能更丰富更强大,使用
ApplicationContext进行开发时,xml配置文件的名称习惯写成applicationContext.xml(约定)
ApplicationContext可以直接进行对xml文件的读取,并在容器内管理一个被声明为Bean的类的对象。
1)创建application.xml(直接把beans.xml赋值一份重命名)
<?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="userService" class="com.tyust.service.impl.UserServiceImpl">
<property name="userDao" ref="userDao"></property>
</bean>
<bean id="userDao" class="com.tyust.dao.impl.UserDaoImpl"></bean>
</beans>
- 编写测试类 创建ApplicationContext的实现类对象 来读取xml文件
public class ApplicationContextTest {
public static void main(String[] args) {
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = (UserService) applicationContext.getBean("userService");
System.out.println(userService);
}
}
4.3 BeanFactory与ApplicationContext的对比
1)BeanFactory是Spring的早期接口,称为Spring的Bean工厂,ApplicationContext是后期更高级接口,称之为
Spring 容器;
2)ApplicationContext在BeanFactory基础上对功能进行了扩展,例如:监听功能、国际化功能等。BeanFactory的
API更偏向底层,ApplicationContext的API大多数是对这些底层API的封装;
3)Bean创建的主要逻辑和功能都被封装在BeanFactory中,ApplicationContext不仅继承了BeanFactory,而且
ApplicationContext内部还维护着BeanFactory的引用,所以,ApplicationContext与BeanFactory既有继承关系,又
有融合关系。
4)Bean的初始化时机不同,原始BeanFactory是在首次调用getBean时才进行Bean的创建,而ApplicationContext则
是配置文件加载,容器一创建就将Bean都实例化并初始化好。
//TODOApplicationContext是一个接口,它内部为啥会维护BeanFactory的引用
4.4基于xml方式的spring应用
4.4.1 Spring的常用配置概览
(1)id与class属性的配置
(2)别名配置
(3)scope属性的配置
scope为singleton的Bean:在未设置lazy-init=true的情况下,Spring容器在进行加载的时候就会创建一个该Bean的实例,并放在Spring容器的单例池中,每次调用getBean时都会去单例池中拿到同一个Bean实例
scope为prototype的Bean,Spring容器初始化时不会创建Bean实例,而是每次调用getBean时才实例化一个Bean,多次调用getBean拿到的不是同一个Bean实例对象,也不会放在单例池中
(4)Bean的lazy-init属性配置延时加载
(5)Bean的初始化和销毁方法
(通过实现InitialzingBean接口并重写afterPropertiesSet方法的初始化方式和自定义的并通过xml中initt-method属性指定的初始化方法可以同时存在,且前者优先于后者执行)
要想让destroy方法执行,需要手动调用ClassPathXmlApplicationContext的close()方法来关闭容器
public class UserDaoImpl implements UserDao, InitializingBean {
public UserDaoImpl() {
System.out.println("执行了构造方法进行实例化");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("执行了afterPropertiesSet初始化方法");
}
public void myInitial()
{
System.out.println("执行我的初始化方法");
}
public void destroy()
{
System.out.println("手动关闭Spring容器,执行UserDaoImol的销毁方法");
}
}
public class ApplicationContextTest {
public static void main(String[] args) {
/**
* Bean的初始化和销毁方法
*/
//这里要用到ClassPathXmlApplicationContext中的手动关闭容器的方法
ClassPathXmlApplicationContext classPathXmlApplicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
classPathXmlApplicationContext.close();
}
}
<?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="userDao" class="com.tyust.dao.impl.UserDaoImpl" init-method="myInitial" destroy-method="destroy" ></bean>
</beans>
(6)Bean的实例化配置(不同的方式实例化Bean)
构造方法来实例化Bean
工厂方式实例化Bean
- 静态工厂方法实例化Bean
2.实例工厂方法实例化Bean
(要通过工厂Bean的实例化对象来调用获取另一个Bean的方法,所以要先把工厂对象加入到Spring容器中去)
- 通过Spring提供的BeanFactory接口规范实现Bean工厂
(不需要再指明方法是哪个,因为我们通过实现接口重写了方法,方法是确定的,这就是规范的作用)
(7)Bean的依赖注入配置
7-1Bean注入的两种方式
7-2对于注入不同类型的属性,xml的依赖注入的配置语法
(这里只对 对集合类型进行注入的语法)
-
List集合
1.1 List类型
1.2 List类型
等价于
- Set类型
3 Map类型
- Properties类型
- 如果要注入的属性也是Bean,可以进行自动注入
(8)Spring的其他配置标签
4.4.2从容器中获取Bean的三种方式
public class ApplicationContextTest2 {
public static void main(String[] args) {
ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//获取Bean的方式1 根据BeanName获取 返回一个Object类型
UserDao userDao1 =(UserDao)classPathXmlApplicationContext.getBean("userDao");
System.out.println(userDao1);
//获取Bean的方式2 根据BeanName+BeanType获取 不需要强转
UserDao userDao2 = classPathXmlApplicationContext.getBean("userDao", UserDao.class);
System.out.println(userDao2);
//获取Bean的方式3 根据类型获取 该类型的Bean的实例化对象在容器中只能有一个 否则会报错 因为不知道去获取哪个
UserDao userDao3 = classPathXmlApplicationContext.getBean(UserDao.class);
System.out.println(userDao3);
}
}
4.4.3Spring配置非自定义Bean
例如:UserDaoImpl,UserServiceImpl,以上在 xml 中配置的Bean都是自己定义的,但是,在实际开发中有些功能类并不是我们自己定义的,而是使用的第三方jar包中的,那么,这些Bean要想让Spring进行管理,也需要对 其进行配置
配置非自定义的Bean需要考虑如下两个问题:
- 被配置的Bean的实例化方式是什么?无参构造、有参构造、静态工厂方式还是实例工厂方式;
- 被配置的Bean是否需要注入必要属性
-
配置Druid数据源交给Spring管理
首先,我们分析一下一般情况下我们自己是如何创建和配置Druid数据源的
DruidDataSource druidDataSource = new DruidDataSource();
druidDataSource.setDriverClassName("com.mysql.jdbc.Driver");
druidDataSource.setUrl("jdbc://localhost:3306/mybatis");
druidDataSource.setUsername("root");
druidDataSource.setPassword("1234");
分析可知,我们通过DruidDataSource()提供的无参构造实例化出druidDataSource对象,并调用其set方法为其注入必要的属性
因此我们在配置Bean时,可以用无参构造的实例化方式,并用set注入(标签)为其注入必要属性
<bean id="druid" class="com.alibaba.druid.pool.DruidDataSource">
<property name="username" value="root"></property>
<property name="password" value="root"></property>
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<property name="url" value="jdbc://localhost:3306/mybatis"></property>
</bean>
-
配置Connection交给Spring容器管理
首先,我们分析一下一般情况下我们是如何创建和配置Connection连接的
Class.forName("com.mysql.jdbc.driver"); //加载驱动 Connection connect = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "1234");
可见,Connect的获取并不是通过构造方法,而是通过DriverManager的静态方法getConnection来获取,因此我们在配置该类的Bean对象时可以用静态工厂方式实例化,然后用为其填充方法参数
<bean id="driver" class="java.lang.Class" factory-method="forName"> <constructor-arg name="className" value="com.mysql.cj.jdbc.Driver"></constructor-arg> </bean> <bean id="connection" class="java.sql.DriverManager" factory-method="getConnection" scope="prototype"> <constructor-arg name="url" value="jdbc:mysql://localhost:3306/test"/> <constructor-arg name="user" value="root"></constructor-arg> <constructor-arg name="password" value="1234"></constructor-arg> </bean>
-
配置Date的Bean对象交给Spring容器管理
首先,我们在一般情况下获取Date的方式
String currentTimeStr = "2023-08-27 07:20:00";
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = simpleDateFormat.parse(currentTimeStr);
可见,Date的实例化是基于SimpleDateFormat的成员方法parse()来实现的,因此我们在配置该类的Bean对象时可以用实例工厂方式初始化,然后用为其填充方法参数
<bean id="driver" class="java.lang.Class" factory-method="forName">
<constructor-arg name="className" value="com.mysql.cj.jdbc.Driver"></constructor-arg>
</bean>
<bean id="connection" class="java.sql.DriverManager" factory-method="getConnection"
scope="prototype">
<constructor-arg name="url" value="jdbc:mysql://localhost:3306/test"/>
<constructor-arg name="user" value="root"></constructor-arg>
<constructor-arg name="password" value="1234"></constructor-arg>
</bean>
- 配置MyBatis的SqlSessionFactory交由Spring管理
一般情况下:
// //加载mybatis核心配置文件,使用静态工厂方式
// InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
// //创建SqlSessionFactoryBuilder对象,使用无参构造方式
// SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
// //调用SqlSessionFactoryBuilder的build方法,实例工厂方式
// SqlSessionFactory sqlSessionFactory = builder.build(in);
<bean id="inputStream" class="org.apache.ibatis.io.Resources" factory-method="getResourceAsStream">
<constructor-arg name="resource" value="mybatis-config.xml"></constructor-arg>
</bean>
<bean id="sqlSessionFactoryBuildler" class="org.apache.ibatis.session.SqlSessionFactoryBuilder"> </bean>
<bean id="sqlSessionFactory" factory-bean="sqlSessionFactoryBuildler" factory-method="build">
<constructor-arg name="inputStream" ref="inputStream"></constructor-arg>
</bean>
4.4.4 Bean实例化的基本流程
Spring容器在进行初始化时,会将xml配置的的信息封装成一个BeanDefinition对象,所有的 BeanDefinition存储到一个名为beanDefinitionMap的Map集合中去,Spring框架在对该Map进行遍历,使用反射创建Bean实例对象,创建好的Bean对象存储在一个名为singletonObjects的Map集合中,当调用getBean方法时则最终从该Map集合中取出Bean实例对象返回。
4.4.5 Spring的后处理器
Spring的后处理器是Spring对外开发的重要扩展点,允许我们介入到Bean的整个实例化流程中来,以达到动态注册 BeanDefinition,动态修改BeanDefinition,以及动态修改Bean的作用。Spring主要有两种后处理器:
⚫ BeanFactoryPostProcessor:Bean工厂后处理器,在BeanDefinitionMap填充完毕,Bean实例化之前执行;
⚫ BeanPostProcessor:Bean后处理器,一般在Bean实例化之后,填充到单例池singletonObjects之前执行。
(1)Bean工厂后处理器(BeanFactoryPostProcessor)
BeanFactoryPostProcessor是一个接口规范,实现了该接口的类只要交由Spring容器管理的话,那么Spring就会回调该接口的方法,用于对BeanDefinition注册和修改的功能
BeanFactoryPostProcessor 定义如下:
public interface BeanFactoryPostProcessor {
void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory);
}
-
小Demo
-
通过Bean工厂后处理器实现对beanDefinitionMap中已有BeanDefinition的修改
-
通过Bean工厂后处理器实现将一个新的BeanDefinition注册到beanDefinitionMap中去
-
Spring 提供了一个BeanFactoryPostProcessor的子接口BeanDefinitionRegistryPostProcessor专门用于注册
BeanDefinition操作
-
使用Spring的BeanFactoryPostProcessor扩展点完成自定义注解扫描
要求如下:
⚫ 自定义@MyComponent注解,使用在类上;
⚫ 使用资料中提供好的包扫描器工具BaseClassScanUtils 完成指定包的类扫描;
⚫ 自定义BeanFactoryPostProcessor完成注解@MyComponent的解析,解析后最终被Spring管理。
-
自定义@MyComponent注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyComponent {
String value();
}
-
在需要被Spring管理其Bean对象的类上加上@MyComponent注解
@MyComponent("myBean1") public class MyBean1 { }
-
引入包扫描工具类 扫描指定包下所有加有@Component注解的类并将其类信息封装为Map集合返回
public class BaseClassScanUtils {
//设置资源规则
private static final String RESOURCE_PATTERN = "/**/*.class";
public static Map<String, Class> scanMyComponentAnnotation(String basePackage) {
//创建容器存储使用了指定注解的Bean字节码对象
Map<String, Class> annotationClassMap = new HashMap<String, Class>();
//spring工具类,可以获取指定路径下的全部类
ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
try {
String pattern = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
ClassUtils.convertClassNameToResourcePath(basePackage) + RESOURCE_PATTERN;
Resource[] resources = resourcePatternResolver.getResources(pattern);
//MetadataReader 的工厂类
MetadataReaderFactory refractory = new CachingMetadataReaderFactory(resourcePatternResolver);
for (Resource resource : resources) {
//用于读取类信息
MetadataReader reader = refractory.getMetadataReader(resource);
//扫描到的class
String classname = reader.getClassMetadata().getClassName();
Class<?> clazz = Class.forName(classname);
//判断是否属于指定的注解类型
if(clazz.isAnnotationPresent(MyComponent.class)){
//获得注解对象
MyComponent annotation = clazz.getAnnotation(MyComponent.class);
//获得属value属性值
String beanName = annotation.value();
//判断是否为""
if(beanName!=null&&!beanName.equals("")){
//存储到Map中去
annotationClassMap.put(beanName,clazz);
continue;
}
//如果没有为"",那就把当前类的类名作为beanName
annotationClassMap.put(clazz.getSimpleName(),clazz);
}
}
} catch (Exception exception) {
}
return annotationClassMap;
}
public static void main(String[] args) {
Map<String, Class> stringClassMap = scanMyComponentAnnotation("com.itheima");
System.out.println(stringClassMap);
}
}
- 创建BeanFactoryPostProcessor接口的实现类,在类中进行BeanDefinition的注册,并将其交给Spring容器管理
public class MyBeanFactoryPostProcessor4 implements BeanDefinitionRegistryPostProcessor {
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
//包扫描出所有加油@MyComponent注解的类信息
Map<String, Class> stringClassMap = BaseClassScanUtils.scanMyComponentAnnotation("com.tyust");
System.out.println(stringClassMap.size());
stringClassMap.forEach(
(beanName,clazz)->{
//定义一个BeanDefinition
BeanDefinition beanDefinition = new RootBeanDefinition();
beanDefinition.setBeanClassName(clazz.getName());
//将BeanDefinition注册到BeanDefinitionMap中去
beanDefinitionRegistry.registerBeanDefinition(beanName,beanDefinition);
}
);
}
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
}
}
<bean class="com.tyust.BeanFactoryPostProcessor.MyBeanFactoryPostProcessor4"></bean>
(2)Bean后处理器(BeanPostProcessor)
Bean被实例化后,到最终缓存到名为singletonObjects单例池之前,中间会经过Bean的初始化过程,例如属性的填充、初始方法init的执行等,其中有一个对外进行扩展的点BeanPostProcessor,我们称为Bean后处理。跟上面的 Bean工厂后处理器相似,它也是一个接口,实现了该接口并被容器管理的BeanPostProcessor,会在流程节点上被 Spring自动调用。
(可以在postProcessAfterInitialization方法中实现动态代理的增强)。
(执行流程 工厂后处理器->实例化->属性注入->Bean后处理器的before方法->初始化方法->Bean后处理器的after方法)
Demo:
4.4.6Spring中Bean的生命周期
(1)定义
Spring Bean的生命周期是从 Bean 实例化之后,即通过反射创建出对象之后,到Bean成为一个完整对象,最终存储到单例池中,这个过程被称为Spring Bean的生命周期。Spring Bean的生命周期大体上分为三个阶段:
⚫ Bean的实例化阶段:Spring框架会取出BeanDefinition的信息进行判断当前Bean的范围是否是singleton的,是否不是延迟加载的,是否不是FactoryBean等,最终将一个普通的singleton的Bean通过反射进行实例化;
⚫ Bean的初始化阶段:Bean创建之后还仅仅是个"半成品",还需要对Bean实例的属性进行填充、执行一些Aware接口方法、执行BeanPostProcessor的before方法、执行InitializingBean接口的初始化方法、执行自定义初始化init方法,执行BeanPostProcessor的after方法等。该阶段Spring最具技术含量和复杂度的阶段,Aop增强功能,后面要学习的Spring的注解功能等、 spring高频面试题Bean的循环引用问题都是在这个阶段体现的;
⚫ Bean的完成阶段:经过初始化阶段,Bean就成为了一个完整的Spring Bean,被存储到单例池singletonObjects中去了,即完成了Spring Bean的整个生命周期。
(2)Bean的初始化过程
1. Bean的属性填充(属性注入)
(获取顺序:一级缓存没有 去二级缓存中取 二级缓存没有 到三级缓存中取 要是三级缓存中还没有 就先创建 再获取)
2.常用的Aware接口
-
SpringIOC流程总结
相关视频链接:https://www.bilibili.com/video/BV1rt4y1u7q5/?spm_id_from=333.337.searchcard.all.click&vd_source=26b90ecbd9022f82b71b0463a9d070e5