为了账号安全,请及时绑定邮箱和手机立即绑定

Spring框架小白的蜕变

西昆仑 JAVA开发工程师
难度初级
时长 3小时50分
学习人数
综合评分99.3
41人评价 查看评价
9.9 内容实用
9.9 简洁易懂
10.0 逻辑清晰
  • Bean的懒加载

    测试:


    @Test

    public void test(){

    ApplicationContext ac=new ClassPathXmlApplicationContext("spring_lanjiazai.xml");

    System.out.println("context被创建了");

    Bean bean=ac.getBean("bean", Bean.class);

    System.out.println(bean);

    结果:

    Bean被创建了

    context被创建了

    main.java.com.Bean懒加载.Bean@b8a1063

    证明:当Spring上下文初始化时,作用域为singleton的Bean就已经被创建好了,而不是通过Spring上下文获取时才去创建。

    Bean懒加载概念:

    Spring容器会在创建容器时提前初始化Singleton作用域的bean,但是如果Bean被标注了lazy-init=“true”,则该Bean只有在其被需要的时候才会被初始化。(只对singleton作用域的bean有效)

    代码:

    <bean id="bean" class="main.java.com.Bean懒加载.Bean" scope="singleton" lazy-init="true"></bean>

    解决多个bean使用懒加载问题:

    <beans标签里添加default-lazy-init=“true”>:表示spring配置文件里所有bean都是懒加载模式。

    使用场景:

    如果某个Bean在程序整个运行周期都可能不会被使用,那么可考虑设定该Bean为懒加载。

    优点:尽可能的节省了资源。

    缺点:可能会导致某个操作相应操作时间增加。




  • IOC(不只是Spring的ioc,其他的框架也具有相同的IOC思想及应用):

            控制: 控制对象的创建及销毁(生命周期)

            反转:将对象的控制权交给IOC容器

  • 这节课内容如下 1 通过注解减少配置 @configuration 相当于spring.xml整个xml的配置 @bean 相当于bean标签 另外可以让spring自动扫描注解,配置@componentScan,效果同component-scan标签 类似@component可以被管理的标签有@controller,@service,@repository 等 2 bean的别名配置 @bean的value可以配一个数组
    05:16
    看视频
  • 实例化Bean的三种方式:构造方法、静态方法、实例方法

    00:33
    看视频
  • 把一个java bean交给spring管理步骤:

    1、创建一个xml格式的配置文件

    2、在xml文件中定义一个bean,给每个bean设定一个id

    3、通过ApplicationContext获取Spring上下文

    ApplicationContext context = new ClassPathXmlApplicatioinContext("文件名.xml");

    4、获取bean

    Bean bean = context.getBeal("第一步中给bean的id",Bean.class);

    05:34
    看视频
  • 通过Spring的xml文件配置Bean作用域:(Spring默认作用域是Singleton)

    1、Singleton作用域(单例模式:通过Spring容器实现单例模式,具有局限性:保证在一个Spring上下文(ApplicationContext)是单例模式,多个AppliactionContext单例模式就失效了。

    定义:如果一个<bean>的作用域为Singleton,则该<bean>只会被实例化一次,只有一个Bean会被创建。(每次向Spring上下文(ApplicationContext生命周期存活)请求这个实例时,Spring都会返回同一个实例)。

    代码:

    public class Bean1 {

    private Bean2 bean2;

    public Bean1(){


    }

    public Bean2 getBean2() {

    return bean2;

    }

    public void setBean2(Bean2 bean2) {

    this.bean2 = bean2;

    }

    }

    public class Bean2 {

    }

    <bean id="bean2" class="main.java.com.Bean作用域.Singleton.Bean2" scope="singleton"></bean>

    <bean id="bean1" class="main.java.com.Bean作用域.Singleton.Bean1">

    <property name="bean2" ref="bean2"></property>

    </bean>

    @Test

    public void test(){

    ApplicationContext context=new ClassPathXmlApplicationContext("spring-singleton.xml");

    Bean2 bean2_1=context.getBean("bean2", Bean2.class);

    System.out.println(bean2_1);

    Bean2 bean2_2=context.getBean("bean2", Bean2.class);

    System.out.println(bean2_2);

    Bean1 bean1=context.getBean("bean1",Bean1.class);

    System.out.println(bean1);


    }

    测试结果:

    main.java.com.Bean作用域.Singleton.Bean2@a690707

    main.java.com.Bean作用域.Singleton.Bean2@a690707

    Bean1 [bean2=main.java.com.Bean作用域.Singleton.Bean2@a690707]


    2、prototype作用域(多例模式)

    定义:如果一个<bean>的作用域为prototype,则该<bean>会被实例化多次,有多个Bean会被创建(每次向Spring上下文请求该Bean都会new一个新的实例)。

    代码:

    public class Bean1 {

    private Bean2 bean2;

    public Bean1(){


    }

    public Bean2 getBean2() {

    return bean2;

    }

    public void setBean2(Bean2 bean2) {

    this.bean2 = bean2;

    }

    }

    public class Bean2 {

    }

    <bean id="bean2" class="main.java.com.Bean作用域.Singleton.Bean2" scope="prototype"></bean>

    <bean id="bean1" class="main.java.com.Bean作用域.Singleton.Bean1">

    <property name="bean2" ref="bean2"></property>

    </bean>

    @Test

    public void test(){

    ApplicationContext context=new ClassPathXmlApplicationContext("spring-singleton.xml");

    Bean2 bean2_1=context.getBean("bean2", Bean2.class);

    System.out.println(bean2_1);

    Bean2 bean2_2=context.getBean("bean2", Bean2.class);

    System.out.println(bean2_2);

    Bean1 bean1=context.getBean("bean1",Bean1.class);

    System.out.println(bean1);

    }

    测试结果:

    main.java.com.Bean作用域.Singleton.Bean2@34dfdf92

    main.java.com.Bean作用域.Singleton.Bean2@55cf055c

    Bean1 [bean2=main.java.com.Bean作用域.Singleton.Bean2@a690707]

    拓展:bean1和bean2分别设置单例模式和多例模式进行不同组合使用。

    1:bean1和bean2都是单例模式,则bean1的实例相等,bean1的属性bean2相等。

    代码:

    <bean id="bean2" class="main.java.com.Bean作用域.Singleton.Bean2" scope="singleton"></bean>

    <bean id="bean1" class="main.java.com.Bean作用域.Singleton.Bean1" scope="singleton">

    <property name="bean2" ref="bean2"></property>

    </bean>

    Bean1 bean1_1=context.getBean("bean1",Bean1.class);

    System.out.println(bean1_1);

    Bean1 bean1_2=context.getBean("bean1",Bean1.class);

    System.out.println(bean1_2);

    System.out.println(bean1_1==bean1_2);

    结果:

    Bean1 [bean2=main.java.com.Bean作用域.Singleton.Bean2@34dfdf92]

    Bean1 [bean2=main.java.com.Bean作用域.Singleton.Bean2@34dfdf92]

    true

    2:bean1是单例模式和bean2都是多例模式,则bean1的实例相等,bean1的属性bean2也相等(因为bean1是单例模式,Spring只实例化一次bean1,bean2只需要被实例化一次)。

    代码:

    <bean id="bean2" class="main.java.com.Bean作用域.Singleton.Bean2" scope="prototype"></bean>

    <bean id="bean1" class="main.java.com.Bean作用域.Singleton.Bean1" scope="singleton">

    <property name="bean2" ref="bean2"></property>

    </bean>

    @Test

    public void test(){

    ApplicationContext context=new ClassPathXmlApplicationContext("spring-singleton.xml");

    Bean1 bean1_1=context.getBean("bean1",Bean1.class);

    System.out.println(bean1_1);

    Bean1 bean1_2=context.getBean("bean1",Bean1.class);

    System.out.println(bean1_2);

    System.out.println(bean1_1==bean1_2);

    }

    Bean1 [bean2=main.java.com.Bean作用域.Singleton.Bean2@55cf055c]

    Bean1 [bean2=main.java.com.Bean作用域.Singleton.Bean2@55cf055c]

    true

    3:bean1是多例模式和bean2都单例模式,则bean1的实例不相等,bean1的属性bean2相等

    代码:

    <bean id="bean2" class="main.java.com.Bean作用域.Singleton.Bean2" scope="singleton"></bean>

    <bean id="bean1" class="main.java.com.Bean作用域.Singleton.Bean1" scope="prototype">

    <property name="bean2" ref="bean2"></property>

    </bean>

    @Test

    public void test(){

    ApplicationContext context=new ClassPathXmlApplicationContext("spring-singleton.xml");

    Bean1 bean1_1=context.getBean("bean1",Bean1.class);

    System.out.println(bean1_1);

    Bean1 bean1_2=context.getBean("bean1",Bean1.class);

    System.out.println(bean1_2);

    System.out.println(bean1_1==bean1_2);

    }

    Bean1 [bean2=main.java.com.Bean作用域.Singleton.Bean2@a690707]

    Bean1 [bean2=main.java.com.Bean作用域.Singleton.Bean2@a690707]

    false

    4:bean1是多例模式和bean2都多例模式,则bean1的实例不相等,bean1的属性bean2不相等

    <bean id="bean2" class="main.java.com.Bean作用域.Singleton.Bean2" scope="prototype"></bean>

    <bean id="bean1" class="main.java.com.Bean作用域.Singleton.Bean1" scope="prototype">

    <property name="bean2" ref="bean2"></property>

    @Test

    public void test(){

    ApplicationContext context=new ClassPathXmlApplicationContext("spring-singleton.xml");

    Bean1 bean1_1=context.getBean("bean1",Bean1.class);

    System.out.println(bean1_1);

    Bean1 bean1_2=context.getBean("bean1",Bean1.class);

    System.out.println(bean1_2);

    System.out.println(bean1_1==bean1_2);

    }

    Bean1 [bean2=main.java.com.Bean作用域.Singleton.Bean2@66e376e1]

    Bean1 [bean2=main.java.com.Bean作用域.Singleton.Bean2@5f91e28c]

    false

    方法注入:声明一个protected、抽象、返回值为被依赖Bean类型的方法。(protected abstract Bean2 createBean2();)

    适用于如下场景——

    <!--此处有图片-->

    bean1是Singleton,bean2是Prototype,Bean1依赖Bean2,每次获得Bean1的时候,正常情况下Bean2是相同的,方法注入则使Bean2不同。

    代码:

    public abstract class Bean1 {

    public abstract Bean2 createBean2();

    public void printBean2(){

    System.out.println(createBean2());

    }

    public Bean1(){

    }

    }

    <bean id="bean2" class="main.java.com.Bean作用域.Singleton.Bean2" scope="prototype"></bean>

    <bean id="bean1" class="main.java.com.Bean作用域.Singleton.Bean1" scope="singleton">

    <lookup-method name="createBean2" bean="bean2"/>

    </bean>

    @Test

    public void test(){

    ApplicationContext context=new ClassPathXmlApplicationContext("spring-singleton.xml");

    Bean1 bean1_1=context.getBean("bean1",Bean1.class);

    System.out.println(bean1_1.createBean2());

    System.out.println(bean1_1.createBean2());

    System.out.println(bean1_1.createBean2());

    }

    测试结果:

    main.java.com.Bean作用域.Singleton.Bean2@2467149d

    main.java.com.Bean作用域.Singleton.Bean2@6b7a6216

    main.java.com.Bean作用域.Singleton.Bean2@2fbdc97a

    3、Web环境作用域(request作用域、session作用域、application作用域、websocket作用域


    4、自定义作用域(Spring内置的自定义SimpleThreadScope作用域

  • 通过Spring的xml文件实现Bean(注意:只要Spring.xml中配置了bean标签,则就会根据class创建这个bean的实例

    1、通过构造方法实例化Bean。

    步骤1:创建要实例化的类,并提供无参构造方法。

    public class Bean {

    public Bean(){

    System.out.println("Bean被创建了");

    }

    步骤2:spring.xml中配置

    <bean id="bean的唯一标识" class="要实例化bean的路径"></bean>

    测试:ApplicationContext context=new ClassPathXmlApplicationContext(spring.xml的路径);

    Bean bean=context.getBean("bean",Bean.class);

    System.out.println(bean);


    2、通过静态方法实例化Bean。(通过Bean2的工厂的静态方法实例化Bean

    步骤1:创建Bean2的工厂Bean2Factory类以及Bean2类,并且提供一个静态、返回值类型为Bean2的方法,返回new Bean2()。

    public class Bean2Factory {

    public static Bean2 getBean2(){

    return new Bean2();

    }

    }

    public class Bean2 {

    public Bean2(){

    System.out.println("Bean2被创建了。");

    }

    步骤2:配置Spring.xml

    <bean class="Bean2工厂的路径" factory-method="Bean2工厂的静态方法名" id="Bean2工厂的唯一标识"></bean>

    测试:

    ApplicationContext context=new ClassPathXmlApplicationContext("spring-ioc2.xml");

    Bean2 bean=context.getBean("bean2factoryId",Bean2.class);

    System.out.println(bean);

    3、通过实例方法实例化Bean。通过Bean2的工厂的实例方法实例化Bean

    步骤1:创建Bean3的工厂Bean3Factory类以及Bean3类,并且提供一个返回值类型为Bean3的方法,方法返回new Bean3()。

    public class Bean3Factory {

    public  Bean3 getBean3(){

    return new Bean3();

    }

    }

    public class Bean3 {

    public Bean3(){

    System.out.println("Bean3被创建了。");

    }

    }

    步骤2:配置Spring.xml

    <bean class="main.java.com.imooc2.Bean3Factory" id="bean3Factory"></bean>

    <bean class="main.java.com.imooc2.Bean3" factory-bean="bean3Factory" factory-method="getBean3" id="bean3"></bean>

    给bean取别名:有类Bean1,并且通过bean标签实例化Bean1,给Bean1的实例取多个名字。

    例如:方式一:bean标签里添加name属性

    <bean id="bean" class="main.java.com.imooc1.Bean" name="bean1_1,bean1_2"></bean>

               方式二:添加<alias>标签

    <bean id="bean" class="main.java.com.imooc2.Bean1" name="bean1_1,bean1_2"></bean>

    <alias name="bean" alias="bean1_3"/><!-- alias只支持一个别名 -->


  • IoC:控制反转

    控制什么?

    控制对象的创建及销毁(生命周期)

    反转什么?

    将对象的控制权交给Ioc容器


    01:38
    看视频
  • bean1单例模式,bean2单例模式

    两个bean1都是同一个实例

  • 感概给bean2家了scope属性,但是没有个bean1加scope属性,在spring中如果没加scope,默认就是单例模式

    现在做另一个实验,现在bean1和bean2是有依赖关系的,

    bean1包含属性是bean2,

    那么bean1和bean2分别作为单例和多例进行组合时会发生什么情况。



    10:05
    看视频
  • 而且通过bean1注入的bean2也是不同的实例

    ,每次向spring上下文请求实例时,拿到的都是全新的实例

    09:10
    看视频
  • 可以看到两次获取的bean2的实例是不同的。

    09:03
    看视频
首页上一页1234567下一页尾页

举报

0/150
提交
取消
课程须知
需要具备Java语法基础,了解Java Web基础知识。
老师告诉你能学到什么?
1、什么是IoC 2、Spring Bean的管理 3、什么是懒加载
意见反馈 邀请有奖 帮助中心 APP下载
官方微信