SpringIOC

职业搬砖小王

于 2024-04-30 19:06:51 发布

阅读量650

点赞数 8

文章标签： spring

本文链接：https://blog.csdn.net/weixin_62486434/article/details/138354502

版权

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的整个生命周期。