Spring框架

关注

原创 2022-03-31 20:14:45 555 阅读 AI 写同款· GEO 优化 ›

spring技术栈面试题其他：选择Spring框架的原因还远不止于此，Spring为Java企业级开发提供了一站式选择，你可以在需要的时候使用它的部分和全部，更重要的是，你甚至可以在感觉不到Spring存在的情况下，在你的项目中使用Spring提供的各种优秀的功能。- IoC容器：IoC容器帮助应用程序管理对象以及对象之间的依赖关系，对象之间的依赖关系如果发生了改变只需要修改配置文件而不是修改代码，因为代码的修改可能意味着项目的重新构建和完整的回归。一致性（consistency）:事务的执行的前后数据的完整性保持一致. 阅读详情

Spring

概念：

Spring框架是一个开源的J2EE应用程序框架，是管理bean的生命周期的轻量级容器（lightweight container）。

*bean：由spring容器管理的对象称为bean

*轻量级：使用spring容器的方式简单，便捷

*容器：spring在容器的内存中开辟一块空间，用来管理对象

Spring IOC介绍

概念：

Ioc全称Inversion of Control，即“控制反转”，这是一种设计思想。Spring框架创建对象.由容器管理对象的生命周期。

在这里插入图片描述

IOC入门案例

准备接口类Pet

package com.jt.demo3;

public interface Pet {
    void hello();
}

Dog实现类

package com.jt.demo3;

public class Dog implements Pet {
    public void hello(){
        System.out.println("汪汪");
    }
}

准备spring.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">
    <!--
        知识点讲解:
            1.bean 被spring容器管理的对象称之为bean
            2.id    全局唯一变量一般类型首字母小写
            3.class class的路径信息,需要写全名
    -->
    <bean id="dog" class="com.jt.demo3.Dog"></bean>
</beans>

编辑user测试对象

package com.jt.demo3;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class User {
    public static void main(String[] args) {
        //指定配置文件
        String resourse="spring.xml";
        //创建容器对象，加载配置文件
        ApplicationContext context=
                new ClassPathXmlApplicationContext(resourse);
        //从容器中获取对象
            //方式一
        Dog dog=context.getBean(Dog.class);
            //方式二，获取id
        Dog dog1=(Dog) context.getBean("dog");
        //调用对象方法属性
        dog.hello();
        dog1.hello();
    }
}

IOC实现原理

容器的数据结构: K-V Map<K,V> key=bean中的ID, value=实例化的对象
程序执行过程:
1. 指定配置文件的名称.
2. 当Spring容器加载配置文件时.当按照顺序执行bean标签时,开始创建对象.
3. Spring通过bean标签中的class属性获取类型的路径,之后通过反射机制,实例化对象(必须有无参构造)
4. bean中的Id当做Map中的key, 将实例化的对象保存到Map中,当做value. 至此Spring容器启动成功!!!
5. 当用户需要获取对象时,可以通过key/或者类型获取对象.

Spring注解开发

备注：由Spring管理的对象的作用域默认是单例的（并不是单例模式），即只创建一个对象，如果希望某个被Spring管理的对象不是单例的，可以在类上添加`@Scope("prototype")`注解；只有在单例模式下才讨论Spring管理的对象的生命周期

(1条消息) 项目中的常用注解_闪耀太阳的博客-优快云博客

先在pom.xml中添加spring-context依赖（https://mvnrepository.com/ ）

关于注解开发说明

如果是2010年,那么还需要对xml配置文件有所了解,但是引入springboot之后,基本不需要使用xml配置文件了,一般都使用注解开发.

spring创建对象的两种方式：

1.通过@Configuration和@bean开发（可用在任意类型，包括自定义类型）

package cn.tedu.spring;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.Random;

@Configuration //标识当前类是配置类
public class SpringBeanFactory {
    @Bean
    public Random random(){
        return new Random();
    }

}

package cn.tedu.spring;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import java.util.Random;

public class SpringRunner {

    public static void main(String[] args) {
        // 1. 加载Spring
        System.out.println("1. 加载Spring，开始……");
        AnnotationConfigApplicationContext ac
                = new AnnotationConfigApplicationContext(SpringBeanFactory.class);
        System.out.println("1. 加载Spring，完成！");
        System.out.println();

        // 2. 从Spring中获取对象
        System.out.println("2. 从Spring中获取对象，开始……");
        Random random = ac.getBean("random", Random.class);
        System.out.println("2. 从Spring中获取对象，完成！");
        System.out.println();

        // 3. 测试使用对象，以便于观察是否获取到了有效的对象
        System.out.println("3. 测试使用对象，开始……");
        System.out.println("\trandom > " + random);
        System.out.println("\trandom.nextInt() > " + random.nextInt());
        System.out.println("3. 测试使用对象，完成！");
        System.out.println();

        // 4. 关闭
        System.out.println("4. 关闭，开始……");
        ac.close();
        System.out.println("4. 关闭，完成！");
    }

}

2. 通过@Configuration和@componentScan("包名")组件扫描（只适用于自定义类型）

@Configuration
@ComponentScan("cn.tedu.spring")
public class SpringConfig {
}

package cn.tedu.spring;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class SpringRunner {

    // @Component
    public static void main(String[] args) {
        // 1. 加载Spring
        System.out.println("1. 加载Spring，开始……");
        AnnotationConfigApplicationContext ac
                = new AnnotationConfigApplicationContext(“cn.tedu.spring”);
        //AnnotationConfigApplicationContext ac
        //       = new AnnotationConfigApplicationContext(SpringConfig.class);
        System.out.println("1. 加载Spring，完成！");
        System.out.println();

        // 2. 从Spring中获取对象
        System.out.println("2. 从Spring中获取对象，开始……");
        UserMapper userMapper = ac.getBean("userMapper", UserMapper.class);
        System.out.println("2. 从Spring中获取对象，完成！");
        System.out.println();

        // 3. 测试使用对象，以便于观察是否获取到了有效的对象
        System.out.println("3. 测试使用对象，开始……");
        System.out.println("\tuserMapper > " + userMapper);
        System.out.println("3. 测试使用对象，完成！");
        System.out.println();

        // 4. 关闭
        System.out.println("4. 关闭，开始……");
        ac.close();
        System.out.println("4. 关闭，完成！");
    }
}

编辑配置类

效果: 和配置文件类似
注解作用: 标识/标记
注解1: @Configuration
注解2: @Bean 作用于方法
注解3: @ComponentScan(“com.jt.demo4”) //包扫描注解: 让spring注解生效!!!

package com.jt.demo4;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration  //标识当前类是配置类
@ComponentScan("com.jt.demo4")  //包扫描注解: 让spring注解生效!!!
public class SpringConfig {
    //作用: 和配置文件类似,管理对象!!!

    /**
     * IOC-写法
     *  1.@Bean 告诉Spring容器,当前方法的名称,为Map中的key
     *    返回值是Map中的value.
     *  2.特殊用法:
     *      常规条件下,Spring通过反射实例化对象.
     *      也可以由用户自己new的方式创建
     * @return
     */
    @Bean
    public Dog dog(){
        return new Dog();
    }
}

编辑测试类

package com.jt.demo4;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class User {

    public static void main(String[] args) {
        ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        Dog dog = context.getBean(Dog.class);
        dog.hello();
    }
}

Spring中的单例和多例问题

概念

单例对象: Spring中保存一份对象.
多例对象: Spring容器负责创建多次对象. 内存中对象多份.

单例/多例测试

注解: @Scope(“singleton”)/@Scope(“prototype”)
结论:
1.Spring容器默认条件下,对象都是单例对象. 节省内存空间!!!
2. Spring容器提供了多例对象的方法,一般适用数据库链接/资源链接等功能…

在这里插入图片描述

Spring中的懒加载

知识回顾:
懒汉式: 用户使用时创建.
饿汉式: 不管需不需要都要创建.

懒加载: 默认条件下Spring容器启动时都会实例化对象. 如果用户使用时创建对象,则使用懒加载机制!!!
规则:
1. spring容器启动,对象创建不是懒加载
2. 当用户使用时创建对象. 是懒加载.

注意事项:
1.如果当前对象是多例模式, 则都是懒加载规则
2.懒加载的控制,只对单例对象有效!!!

在这里插入图片描述

Spring管理的对象的生命周期

由Spring创建并管理对象，则开发人员就没有了对象的控制权，无法对此对象的历程进行干预，而Spring允许在类中自定义最多2个方法，分别表示初始化方法和销毁方法，并且，Spring会在创建对象之后就执行初始化方法，在销毁对象之前执行销毁方法。

关于这2个方法，你可以按需添加，例如，当你只需要干预销毁过程时，你可以只定义销毁的方法，不需要定义初始化方法。

关于这2个方法的声明：

访问权限：推荐使用public
返回值类型：推荐使用void
方法名称：自定义
参数列表：推荐为空

然后，需要在初始化方法的声明之前添加@PostConstruct注解，在销毁方法的声明之前添加@PreDestroy注解。

用@Component也可以创建对象

package cn.tedu.spring;

import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Component
public class UserMapper {
    public UserMapper() {
        System.out.println("\tUserMapper.UserMapper()");
    }

    @PostConstruct
    public void init(){
        System.out.println("userMapper.init()");
    }
    @PreDestroy
    public void destory(){
        System.out.println("userMapper.destory()");
    }
}

package cn.tedu.spring;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class SpringRunner {

    // @Component
    public static void main(String[] args) {
        // 1. 加载Spring
        System.out.println("1. 加载Spring，开始……");
        AnnotationConfigApplicationContext ac
                = new AnnotationConfigApplicationContext(UserMapper.class);
        System.out.println("1. 加载Spring，完成！");
        System.out.println();

        // 2. 从Spring中获取对象
        System.out.println("2. 从Spring中获取对象，开始……");
        UserMapper userMapper=ac.getBean("userMapper",UserMapper.class);
        System.out.println("2. 从Spring中获取对象，完成！");
        System.out.println();

        // 3. 测试使用对象，以便于观察是否获取到了有效的对象
        System.out.println("3. 测试使用对象，开始……");
        System.out.println("UserMapper");
        System.out.println("3. 测试使用对象，完成！");
        System.out.println();

        // 4. 关闭
        System.out.println("4. 关闭，开始……");
        ac.close();
        System.out.println("4. 关闭，完成！");
    }
}

运行结果

1. 加载Spring，开始……
	UserMapper.UserMapper()
userMapper.init()
1. 加载Spring，完成！

2. 从Spring中获取对象，开始……
2. 从Spring中获取对象，完成！

3. 测试使用对象，开始……
UserMapper
3. 测试使用对象，完成！

4. 关闭，开始……
userMapper.destory()
4. 关闭，完成！

单词：

configuration：配置

annotation：注释

scope：范围