Spring框架

原创已于 2022-03-31 20:14:45 修改 · 527 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#spring #java #后端

于 2022-01-21 19:45:25 首次发布

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：范围