Spring-定义、功能、Ioc/DI、Junit、作用域(singleson、prototype)、惰性初始化

时间:2021-08-20
本文章向大家介绍Spring-定义、功能、Ioc/DI、Junit、作用域(singleson、prototype)、惰性初始化,主要包括Spring-定义、功能、Ioc/DI、Junit、作用域(singleson、prototype)、惰性初始化使用实例、应用技巧、基本知识点总结和需要注意事项,具有一定的参考价值,需要的朋友可以参考一下。

0.对前面学习的总结

  前面初步使用了Spring MVC 和 Spring Boot,大概总结如下:

  • Spring MVC:

    Controller 和 java与页面的交互,都是Spring MVC的功能

    M: Model模型,狭义上指实体类, 广义上指除了控制器之外的其它java类

    V: View视图,html页面, 即显示给用户看到的界面

    C: Controller控制器,Controller类,视图与java进行数据交互的

    Spring MVC框架简化了V和C之间的数据交互过程

  • Spring Boot:

    boot : 启动

    支持Spring Boot框架的项目内置了很多配置,这些配置都是大部分框架的常规配置,当我们使用这些框架时,就免去了那些繁琐的配置。除了这些配置之外,还包含了一些约定:例如static文件夹存放静态资源等。

1.什么是Spring?

  Spring本身的意思是春天、泉水,Spring是一个基础框架,Spring MVC、Spring Boot、Spring Data、Spring Security、Spring Validation、Spring Cloud都是Spring框架衍生出来的以及众多以Spring开头的框架的基础。它的出现是现在java能够长盛不衰的主要原因。因为它提供了一个java开发的生态环境,几乎市面上任何通用的常用需求,Spring都有解决方案。

2.Spring框架的功能

  • Ioc\DI (主要讲解内容):Ioc是一种思想,DI是基于Ioc的操作。

  • Aop (最后讲解内容)

2.1 什么是Ioc?

  • Ioc(Inversion of Control) 翻译为:控制反转,正常的控制称之为主动控制

  • 主动控制: 我们编写的程序主动控制对象组件的产生,再编写对象组件互相调用,以完成程序功能

  • 控制反转: 我们编写的程序需要的对象组件保存在外部容器中,需要时从容器中获取,之后调用方法实现功能

2.2 Spring 实现Ioc

(1)首先创建一个Maven项目,默认配置即可

  注意:Maven项目不同于普通项目,因为里面包含pom.xml文件,可以添加组件依赖,方便管理依赖,而普通项目需要单独导入jar包,当jar包较多时,不方便管理,使用不便。Spring Boot内置Maven!

(2)项目的pom.xml中添加依赖

 <?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
     <groupId>org.example</groupId>
     <artifactId>SpringDemo</artifactId>
     <version>1.0-SNAPSHOT</version>
     <dependencies>
         <!--Spring框架:添加Spring Context依赖-->
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-context</artifactId>
             <version>5.2.2.RELEASE</version>
         </dependency>
 
        <!--JUnit单元测试框架-->
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
             <version>4.13</version>
         </dependency>
     </dependencies>
 
 </project>

注意:先添加依赖(代码正确),再刷新Maven,等待下载完毕即可!

maven下载资源失败的解决方案:

1.检查setting.xml文件的位置是否设置了阿里\华为的镜像

2.退出所有防火墙或电脑管家等占用电脑资源的程序

3.更换网络再试(手机热点,手机共享网络给电脑)

4.安装maven(可以从苍老师网站下载)

5.删除.m2文件夹下的repository文件夹,再导入依赖,刷新Maven

(3)详细步骤

在src/main/java路径下创建一个包hello,包下创建类Stu,类中编写代码如下:

 package hello;
 
 /**
  * 1.实体类Stu
  */
 public class Stu {
     private String name;
     private Integer age;
 
     public String getName() {
         return name;
    }
 
     public void setName(String name) {
         this.name = name;
    }
 
     public Integer getAge() {
         return age;
    }
 
     public void setAge(Integer age) {
         this.age = age;
    }
 
     @Override
     public String toString() {
         return "Stu{" +
                 "name='" + name + '\'' +
                 ", age=" + age +
                 '}';
    }
 }

包下编写配置类Config,常见的将对象保存到Spring容器中的方法有两个

我们先介绍第一个:@Bean方式

 package hello;
 
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
 /**
  * 2.Spring配置类
  * 配置Spring容器中内容
  */
 //标准情况下,Spring配置类要添加下面的注解:@Configuration
 @Configuration
 public class Config {
     //编写注解@Bean,注解下写方法,这个方法返回的对象,就会保存到Spring容器中
     @Bean
     public Stu stu(){//注意:调用id时注意写这个方法名
         //实际上每个保存到Spring容器中的对象都要有一个唯一的名字
         //这个名字就是这个方法的方法名
         //简单来说,这个杨过对象在Spring容器中的id就是stu
         Stu stu = new Stu();
         stu.setName("杨过");
         stu.setAge(26);
         return stu;
    }
 }
 

包下新建测试类:获得Spring容器中的对象

 package hello;
 
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 
 /**
  * 3.测试:获得Spring容器中的对象
  */
 public class Test {
     public static void main(String[] args) {
         //初始化Spring容器,参数为配置类的反射
         AnnotationConfigApplicationContext acac = new AnnotationConfigApplicationContext(Config.class);//快捷键ACAC,然后回车
 
         //从Spring容器中获取对象
         //getBean方法两个参数:
         //1.想获得的对象在Spring容器中的id(唯一的名字:@Bean时对应方法名)
         //2.获得对象类型的反射(不需要强转,直接返回这个类型的对象)
         Stu stu = acac.getBean("stu",Stu.class);
         System.out.println(stu);
         acac.close();//关闭资源
    }
 }
 

输出结果:Stu{name='杨过', age=26}

2.3 利用单元测试框架JUnit运行Spring

  我们之前使用过Junit来测试程序运行,Junit测试程序有很多好处,例如一个测试类可以编写多个可以直接运行的方法,来减少main方法和类的数量。

  在maven项目的pom.xml文件中添加junit的依赖,刷新Maven

 <!--JUnit单元测试框架-->
 <dependency>
     <groupId>junit</groupId>
     <artifactId>junit</artifactId>
     <version>4.13</version>
 </dependency>

  在我们测试Spring的方法中,发现实例化ACAC对象和ACAC对象的关闭是每次都要编写执行的,我们可以利用Junit的@Before和@After这两个注解减少冗余代码,简化编写。

  src下面有两个路径:main和test,它们的子文件中都包含java文件夹,其中main下面的java主要存储我们日常编写的程序,test下面的java主要是对上面编写程序的测试,虽然名字相同,但是具有不同的功能。在编写测试类时,尽量与上面的包同名,以便测试类中可以直接调用编写好的类,不需要导包。同时,注意测试类的名字不能为Test,因为测试时需要用到@Test注解,会发生冲突。

在test/java路径下,新建包hello,编写HelloTest的代码如下:

 package hello;
 
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 
 public class HelloTest {
     //声明ACAC为成员变量,方便每个方法使用(Java中叫做成员变量,有的语言中也叫全局变量)
     AnnotationConfigApplicationContext acac;
 
     //测试类中的@Before注解,注解下的方法会在@Test标记的方法运行之前自动运行
     @Before
     public void init(){
         //初始化Spring容器,参数为配置类的反射
         acac = new AnnotationConfigApplicationContext(Config.class);
    }
 
     //测试类中的@After注解,注解下的方法会在@Test标记的方法运行之后自动运行
     @After
     public void destroy(){
         //关闭资源
         acac.close();
    }
 
     //测试类中的方法上加@Test注解,可以直接运行该方法
     @Test
     public void test(){//直接运行该test方法
         //从Spring容器中获取对象
         Stu stu = acac.getBean("stu",Stu.class);
         System.out.println(stu);
    }
 }
 

输出结果:Stu{name='杨过', age=26}

2.4 将对象保存到Spring容器中方法2:Spring 组件扫描

  除了上面章节中给大家介绍的@Bean方式可以将对象保存到Spring容器中,还有组件扫描方式可以将对象保存到Spring容器中。

  在main/java路径下,新建包ioc,包中创建类Hero

 package ioc;
 
 import org.springframework.context.annotation.Lazy;
 import org.springframework.context.annotation.Scope;
 import org.springframework.stereotype.Component;
 //@Component(组件):这个注解一旦标记,表示当前类要自动实例化对象,保存到Spring容器中
 //这个对象保存到Spring容器中的id就是当前类名,只是首字母要小写
 //此处直接设置对象属性,适用于对象属性不需要改变的情况
 @Component
 public class Hero {
     private String name= "关羽";
     private String job = "战士";
 
     public Hero(){
         System.out.println("Hero实例化");
    }
 
     public String getName() {
         return name;
    }
 
     public void setName(String name) {
         this.name = name;
    }
 
     public String getJob() {
         return job;
    }
 
     public void setJob(String job) {
         this.job = job;
    }
 
     @Override
     public String toString() {
         return "Hero{" +
                 "name='" + name + '\'' +
                 ", job='" + job + '\'' +
                 '}';
    }
 }
 

包下编写配置类Config

 package ioc;
 
 import org.springframework.context.annotation.ComponentScan;
 import org.springframework.context.annotation.Configuration;
 
 @Configuration
 //如果想启动组件扫描的注入方式(即:如果想让Hero类上的@Component生效),
 //则还要在配置类中声明扫描的包
 @ComponentScan("ioc")
 public class Config {
 
 }
 

同样按照上面的方法,转到测试类进行测试

 package ioc;
 
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 
 public class IocTest {
     AnnotationConfigApplicationContext acac;
     @Before
     public void init(){
         acac = new AnnotationConfigApplicationContext(Config.class);
    }
     @After
     public void destroy(){
         acac.close();
    }
     @Test
     public void run(){
         Hero hero = acac.getBean("hero",Hero.class);
         System.out.println(hero);
    }
 }
 

输出结果:Hero{name='关羽', job='战士'}

组件扫描流程:

1.实例化ACAC对象时,指定Config类的反射

2.这个Config类上如果有@ComponentScan注解,并指定了包

3.扫描这个包中的所有类(包括子孙包中的所有类)

4.如果某个类上带有支持组件扫描方式保存该类对象到Spring容器的注解(例如@Component)

5.实例化这个对象,并将这个对象保存到Spring容器中,注意:id是这个类名首字母小写

2.5 保存到Spring的细节

  • 除了@Component,还有以下常见注解有相同功能

    • @Controller \ RestController 控制器

    • @Service 业务逻辑

    • @Repository 数据访问

    • .....

  为什么功能一样要设计这么多的注解呢?原因是见到注解名称,就知道这个类的作用(见名知意)

  • 关于特殊的类名

    我们已经学习使用组件扫描时,当前类型对象的id是当前类名首字母小写,但是有特殊情况:如果有类名连续两个以上字母都是大写,例如:VIPStu,那么它保存到Spring容器中的id就是类名(原类名)。

  • 自定义组件ID

    如果有特殊原因不能或不希望类名做id,我们可以自定义组件id,例如:

     @Component("myHero")
     public class Hero {
        ...
     }
     //注意:此时测试类中的id要改变
     //Hero hero = acac.getBean("myHero",Hero.class);

    当然,其它支持组件扫描的注解,也可以用这个方法定义id,一般都是被动使用。

3.Spring中对象的作用域

3.1 作用域(Scope)概述

我们的飞机大战项目中,一共有6个类型,这6个类型中就涉及了我们要讲的两种作用域:

单例(singleton):从程序开始到程序结束,某个类型的对象始终只有一个

天空和英雄机就是单例

原型(prototype): 从程序开始到程序结束,某个类型不断出现新的对象,没有数量的限制(需要时就初始化创建新的对象)

小敌机,大敌机,小蜜蜂,子弹

3.2 单例(singleson)作用域

默认情况下,所有保存到Spring容器中的对象都是单例(singleton)(节省内存,原型要创建多个对象,占用内存)

 @Test
 public void singleton(){
     //从Spring容器中获得两次hero,虽然名字不同,但两次获得的对象完全相同,指同一对象
     Hero hero1 = acac.getBean("hero",Hero.class);
     Hero hero2 = acac.getBean("hero",Hero.class);
     //因为默认情况下,Spring容器中对象都是singleton
     //所以hero1和hero2是相同的引用,指向同一个对象
     hero1.setJob("法师");
     System.out.println(hero2);//Hero{name='关羽', job='法师'}   修改1影响2,因为是同一对象
     System.out.println(hero1==hero2);//true
 }

3.3 原型(prototype)作用域

修改默认scope,将对象修改为prototype(原型)的scope

@Bean保存方式中的设置:

 @Bean
 @Scope("prototype")
 public Stu stu(){
     //代码略
 }

组件扫描方式保存的设置:

 @Component
 @Scope("prototype")
 public class Hero {
     // 代码略
 }

测试代码:

 @Test
 public void prototype(){
         //在@Component注解下编写了@Scope("prototype")注解
         //修改了当前Hero类为原型Scope
         Hero hero1 = acac.getBean("hero",Hero.class);
         Hero hero2 = acac.getBean("hero",Hero.class);
         //原型模式下,每次获得Hero对象Spring都会实例化一个新的对象返回
         //这样就造成了上面两个对象是不同引用的两个不同对象
         hero1.setJob("刺客");
         System.out.println(hero1);//Hero{name='关羽', job='刺客'}
         System.out.println(hero2);//Hero{name='关羽', job='战士'} 不受hero1的影响
         System.out.println(hero1==hero2);//false
 }

今后使用Spring框架的时候,如果需要设置Scope,根据这两个特性来设置修改即可。

4.惰性初始化(懒惰初始化)

  Spring容器中大部分对象都是单例的,单例对象会在实例化Spring容器时进行对象的实例化,也就是说实例化Spring容器时会有大量对象进行实例化。针对实例化时会消耗较多资源,但是运行过程中又不一定使用到的对象,我们可以设置为懒惰初始化。

使用@Lazy表示懒惰初始化

@Bean对象设置懒惰加载:

 @Bean
 @Lazy
 public Stu stu(){
     //代码略
 }

组件扫描的方式设置懒惰加载:

 @Component
 @Lazy
 public class Hero {
     // 代码略
 }

测试代码:

 package ioc;
 
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 
 public class IocTest {
     AnnotationConfigApplicationContext acac;
     @Before
     public void init(){
         acac = new AnnotationConfigApplicationContext(Config.class);
         System.out.println("init方法运行完毕");
    }
     @After
     public void destroy(){
         acac.close();
    }
     @Test
     public void run(){
         Hero hero = acac.getBean("hero",Hero.class);
         System.out.println(hero);
    }
     @Test
     public void singleton(){
         //从Spring容器中获得两次hero,虽然名字不同,但两次获得的对象完全相同,指同一对象
         Hero hero1 = acac.getBean("hero",Hero.class);
         Hero hero2 = acac.getBean("hero",Hero.class);
         //因为默认情况下,Spring容器中对象都是singleton
         //所以hero1和hero2是相同的引用,指向同一个对象
         hero1.setJob("法师");
         System.out.println(hero2);
         System.out.println(hero1==hero2);
    }
 
     @Test
     public void prototype(){
         //在@Component注解下编写了@Scope("prototype")注解
         //修改了当前Hero类为原型Scope
         Hero hero1 = acac.getBean("hero",Hero.class);
         Hero hero2 = acac.getBean("hero",Hero.class);
         //原型模式下,每次获得Hero对象Spring都会实例化一个新的对象返回
         //这样就造成了上面两个对象是不同引用的两个不同对象
         hero1.setJob("刺客");
         System.out.println(hero1);
         System.out.println(hero2);//不受hero1的影响
         System.out.println(hero1==hero2);
    }
 
     //通过测试验证实例化对象的运行顺序
     @Test
     public void lazy(){
         System.out.println("lazy方法运行");
         Hero hero = acac.getBean("hero",Hero.class);
         System.out.println(hero);
    }
 }
 

输出结果:

 init方法运行完毕
 lazy方法运行
 Hero实例化
 Hero{name='关羽', job='战士'}

非Lazy情况下输出结果:

 Hero实例化
 init方法运行完毕
 lazy方法运行
 Hero{name='关羽', job='战士'}

  正常情况下,是在init的时候实例化对象,而输出的结果证明我们的设置生效了,是在acac.getBean方法的位置才实例化的Hero对象。如果方法中没有获得Hero对象的代码,这个对象就不会实例化了。所以通过使用惰性初始化可以针对个别对象节省内存。

  什么时候需要使用这个对象?什么时候懒惰初始化的对象才会实例化?

  惰性初始化可以针对个别对象节省内存,不宜大范围使用,因为大范围使用会引起运行压力大\缓慢。由于prototype是在需要的时候产生对象,所以不能和Lazy一起使用。

5.DI

5.1 什么是DI?

  DI(Dependency Injection)依赖注入

  Ioc是控制反转,它是一种编程思想,DI是基于控制反转思想的一种操作,要明确依赖注入的原因和作用,我们要先了解"依赖的概念"。

5.2 什么是依赖?

  依赖指程序中A类需要使用到B类型对象的情况,那么就说A类依赖B类。

要在Spring中实现这个依赖过程,我们要创建如下类来演示:

青龙偃月刀类

 package san;
 
 public class DragonBlade {
     private String name = "青龙偃月刀";
 
     public String getName() {
         return name;
    }
 
     public void setName(String name) {
         this.name = name;
    }
 
     @Override
     public String toString() {
         return name;
    }
 }
 

关羽类

 package san;
 
 public class GuanYu {
     private String name = "关云长";
     //在GunaYu类中声明了属性DragonBlade
     //这就是依赖关系,关羽依赖青龙偃月刀
     private DragonBlade dragonBlade;
 
     public void fight(){
         //dragonBlade自动调用toString输出名字
         System.out.println(name+"使用"+dragonBlade+"战斗");
    }
     public String getName() {
         return name;
    }
 
     public void setName(String name) {
         this.name = name;
    }
 
     public DragonBlade getDragonBlade() {
         return dragonBlade;
    }
 
     public void setDragonBlade(DragonBlade dragonBlade) {
         this.dragonBlade = dragonBlade;
    }
 
 }
 

关羽依赖青龙偃月刀,在配置类中:

 package san;
 
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
 @Configuration
 public class Config {
     @Bean
     public DragonBlade blade(){
         return new DragonBlade();
    }
     @Bean
     public GuanYu guanYu(){
         return new GuanYu();;
    }
 }
 

测试类让关羽战斗:

 package san;
 
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 
 public class SanTest {
     AnnotationConfigApplicationContext acac;
     @Before
     public void init(){
         acac = new AnnotationConfigApplicationContext(Config.class);
    }
     @After
     public void destroy(){
         acac.close();
    }
     @Test
     public void diTest(){
         //先获得青龙偃月刀
         DragonBlade blade = acac.getBean("blade",DragonBlade.class);
         //再获得关羽
         GuanYu guanYu = acac.getBean("guanYu",GuanYu.class);
         //把刀赋给关羽
         guanYu.setDragonBlade(blade);
         //关羽拿刀战斗
         guanYu.fight();
    }
 }
 

我们经过配置看到测试代码,逻辑和之前主动控制没有什么多大区别,但是使用依赖注入可以简化这个流程。

实现依赖注入:修改Config配置

 package san;
 
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
 @Configuration
 public class Config {
     @Bean
     public DragonBlade blade(){
         return new DragonBlade();
    }
     //实现依赖注入
     //GuanYu方法的参数列表中声明DragonBlade
     //Spring会自动从Spring容器中找到匹配的对象赋值
     @Bean
     public GuanYu guanYu(DragonBlade blade){
         GuanYu guanYu = new GuanYu();
         guanYu.setDragonBlade(blade);
         return guanYu;
    }
 }
 

测试类修改代码运行:

 @Test
 public void diTest(){
     //直接获得关羽
     GuanYu guanYu=acac.getBean("guanYu",GuanYu.class);
     //关羽战斗,是带着刀的
     guanYu.fight();
 }

所谓依赖注入,就是将两个或更多类的依赖关系实现在Spring容器内部,从Spring容器中获取时,是一个已经注入好依赖对象的对象。

原文地址:https://www.cnblogs.com/XiaoCui-blog/p/15168254.html