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

Spring框架小白的蜕变

难度初级
时长 3小时50分
学习人数
综合评分9.93
59人评价 查看评价
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为懒加载。

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

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




  • 通过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(不只是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的继承在spring中的配置方式 可配置parent属性, 就算没有父类,也可以配置一个abstract 的bean,让其他bean设置parent,以配置相同属性
    11:40
    看视频
  • 实例化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
    看视频
  • 通过注解实现Bean的初始化和销毁的逻辑处理(三种方式)

    @PostConstruct:自定义初始化方法的标签。

    @PreDestroy:自定销毁方法的标签。

    方式一:Bean类实现InitializingBean、DisposableBean,并实现afterPropertiesSet()和destroy()。

    代码:


    @Component(value="bean2")

    public class Bean2 implements InitializingBean,DisposableBean {


    @Override

    public void destroy() throws Exception {

    System.out.println("Bean的销毁逻辑方法执行了");

    }


    @Override

    public void afterPropertiesSet() throws Exception {

    System.out.println("Bean的初始化逻辑方法执行了");

    }


    }

    测试:

    @Test

    public void test(){

    AbstractApplicationContext ac=new AnnotationConfigApplicationContext(Configuration2.class);

    Bean2 bean=ac.getBean("bean2",Bean2.class);

    System.out.println(bean);

    ac.close();

    }

    结果:


    Bean的初始化逻辑方法执行了

    springinit_destory.Bean2@46a7cbfd

    Bean的销毁逻辑方法执行了

    方式二:不用实现接口,自定义方法,初始化方法添加@PostConstruct

    销毁方法添加@PreDestroy。


    @Component(value="bean2")

    public class Bean2 {

    @PostConstruct

    public void onInit(){

    System.out.println("Bean的初始化逻辑方法执行了");

    }

    @PreDestroy

    public void destory(){

    System.out.println("Bean的销毁逻辑方法执行了");

    }

    }

    方式三:Bean的管理不通过@Component,而是通过@Bean,提供方法管理,Bean里提供的初始化和销毁方法不用添加注解,而是通过@Bean(initMethod=“初始化方法名”destroyMethod=“销毁方法名”)。

    代码:


    @Configuration

    public class Configuration2 {

    @Bean(initMethod="onInit",destroyMethod="destory",name="bean2")

    public Bean2 bean(){

    return new Bean2();

    }

    }



  • 通过注解开启Bean的懒加载

    懒加载:创建spring上下文时,并不会实例化Bean,而是在获取Bean时,才去实例化Bean。

    步骤1:创建配置扫描文件,并添加注解@Configuration,@ComponentScan(“路径”),这种在@Component下添加注解@Lazy,也可以不添加扫描注解,可以提供一个返回Bean实例的方法,并在方法上添加@Bean注解,通过这种实现懒加载,则在@Bean下添加注解@Lazy。

    @Configuration

    @ComponentScan("springlazy")

    public class Configuration1 {

    @Bean(name="bean2")

    @Lazy

    public Bean1 bean(){

    return new Bean1();

    }

    }

    步骤2:Bean类代码。


    @Component(value="bean1")

    @Lazy

    public class Bean1 {

    public Bean1(){

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

    }

    }

    xml在<beans>标签里添加default-lazy-init通过注解实现。

    @Configuration注解下添加@Lazy注解:该容器中所有作用域为singleton的Bean对象都会被懒加载。

    代码:


    @Configuration

    @ComponentScan("springlazy")

    @Lazy

    public class Configuration1 {

    @Bean(name="bean2")

    public Bean1 bean(){

    return new Bean1();

    }

    }





  • 通过注解设定Bean的作用域Scope

    一、Singleton作用域、prototype作用域、Web环境作用域(request作用域、session作用域、application作用域、websocket作用域)

    @Scope(value=""):实现实例化Bean的作用域功能。

    实现Bean的多例模式:

    Bean代码:


    @Component(value="bean1")

    @Scope(value="prototype")

    public class Bean11 {


    }

    Configuration代码:


    @Configuration

    @ComponentScan("springscope")

    public class Configuration11 {

    @Bean(name="bean2")

    @Scope(value="prototype")

    public Bean11 getBean(){

    return new Bean11();

    }

    }

    测试代码:


    @Test

    public void test(){

    ApplicationContext ac=new AnnotationConfigApplicationContext(Configuration11.class);

    for(int i=0;i<10;i++){

    Bean11 bean=ac.getBean("bean1", Bean11.class);

    System.out.println(bean);

    }

    System.out.println("=================================");

    for(int i=0;i<10;i++){

    Bean11 bean1=ac.getBean("bean2",Bean11.class);

    System.out.println(bean1);

    }

    }

    结果:


    springscope.Bean11@7cd3258f

    springscope.Bean11@a470f4f

    springscope.Bean11@3f3e10ce

    springscope.Bean11@3c164d2

    springscope.Bean11@dc218eb

    springscope.Bean11@41f1f35b

    springscope.Bean11@739ffd2f

    springscope.Bean11@ca753f7

    springscope.Bean11@3d79839e

    springscope.Bean11@74b01999

    =================================

    springscope.Bean11@672add5f

    springscope.Bean11@2f2bbce3

    springscope.Bean11@607df346

    springscope.Bean11@6ceeaa27

    springscope.Bean11@28e51e50

    springscope.Bean11@5a292b29

    springscope.Bean11@44d0befd

    springscope.Bean11@64aaf756

    springscope.Bean11@145462bc

    springscope.Bean11@301e2f11

    二、自定义作用域
    步骤1:根据spring.xml中自定义作用域配置,应该先实例化MyScope,所以先通过注解方式来实例化MyScope。

    代码:

    @Bean

    public MyScope myScope(){

    return new MyScope();

    }


    步骤2:根据spring.xml中自定义作用域配置,通过注解再实例化一个CustomScopeConfigurer,再通过该对象的addScope(String scopeName,Scope scope)方法来实现xml中的<map>标签的功能。

    代码:


    @Bean

    public CustomScopeConfigurer customScopeConfigurer(){

    CustomScopeConfigurer csc=new CustomScopeConfigurer();

    csc.addScope("myScope",myScope());

    return csc;

    }

    问题:CustomScopeConfigurer该对象没有addScope方法。

    通过注解实现方法注入:(Bean的作用域为singleton,AnotherBean的作用域为prototype?)? 



  • Spring通过注解注入Bean

    @Autowired:通过该注解实现构造方法注入和set方法注入,可以标识在有参构造方法上、set方法上、属性上。

    一、通过方法注入Bean

    1:通过有参构造方法注入

    步骤1:创建扫描配置类,并添加注解@Configuration、@ComponentScan(value=“路径”)

    代码:

    @Configuration

    @ComponentScan(value="springzhuru")

    public class MyConfiguration {

    }

    步骤2:创建要实例化的Bean,并提供有参的构造方法,并在构造方法上添加注解@Autowired在类上添加@Component。
    代码:

    @Component

    public class MyBean {

    private AnotherBean anotherBean;

    @Autowired

    public MyBean(AnotherBean anotherBean) {

    super();

    this.anotherBean = anotherBean;

    }

    测试代码:


    @Test

    public void test(){

    ApplicationContext ac=new AnnotationConfigApplicationContext(MyConfiguration.class);

    MyBean bean1=ac.getBean("myBean",MyBean.class);

    System.out.println(bean1);

    }

    结果:

    MyBean [anotherBean=springzhuru.AnotherBean@27b47740]



    2:通过set方法注入


    步骤1:创建扫描配置类,并添加注解@Configuration、@ComponentScan(value=“路径”)

    代码:

    @Configuration

    @ComponentScan(value="springzhuru")

    public class MyConfiguration {


    }

    步骤2:创建要实例化的Bean,并提供set方法,并在set方法上添加注解@Autowired在类上添加@Component。


    @Component(value="myBean")

    public class MyBean {

    private AnotherBean anotherBean;

    private AnotherBean anotherBean1;

    @Autowired

    public MyBean(AnotherBean anotherBean) {

    super();

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

    this.anotherBean = anotherBean;

    }

    @Autowired

    public void setAnotherBean1(AnotherBean anotherBean1) {

    this.anotherBean1 = anotherBean1;

    }

    @Override

    public String toString() {

    return "MyBean [anotherBean=" + anotherBean + ", anotherBean1=" + anotherBean1 + "]";

    }

     

    }

    测试:

    @Test

    public void test(){

    ApplicationContext ac=new AnnotationConfigApplicationContext(MyConfiguration.class);

    MyBean bean1=ac.getBean("myBean",MyBean.class);

    System.out.println(bean1);

    }

    结果:anotherBean和anotherBean1相等,@Component是默认单例模式,同一spring上下文中只会创建一个AnotherBean的对象。

    MyBean [anotherBean=springzhuru.AnotherBean@3c8587f, anotherBean1=springzhuru.AnotherBean@3c8587f]

    二、集合类型Bean的注入

    1、List集合类型Bean的注入

    步骤1:创建注入Bean的类(包括创建集合类型的属性,基本类型的作为Bean的属性),并提供set方法,添加@Resource注解。

    public class MyBean {

     private List<String> stringList;

    public List<String> getStringList() {

    return stringList;

    }

    @Resource        //@Resource注解首先会根据属性名称注入,其次会根据类型进行注入。

    public void setStringList(List<String> stringList) {

    this.stringList = stringList;

    }

    }

    步骤2:扫描配置类,提供List<String>类型的实例的方法,并添加@Bean注解,告知spring由spring管理的方法。

    @Bean

    public List<String> stringList(){

    List<String> list=new ArrayList<String>();

    list.add("哈哈");

    list.add("嘿嘿");

    list.add("呵呵");

    return list;

    }

    测试:


    @Test

    public void test(){

    ApplicationContext ac=new AnnotationConfigApplicationContext(MyConfiguration.class);

    MyBean myBean=ac.getBean("myBean",MyBean.class);

    System.out.println(myBean);

    for (String s:myBean.getStringList()) {

    System.out.println(s);

    }

    }

    通过注解注入List的第二种方式:在扫描配置类中添加几个返回类型为字符串类型的方法,返回的字符串都会被注入到Bean的集合属性中。

    @Configuration

    @ComponentScan(value="springzhuru")

    public class MyConfiguration {


    @Bean

    public String string1(){

    return "111";

    }

    @Bean

    public String string2(){

    return "222";

    }

    }

    测试:


    MyBean [anotherBean=springzhuru.AnotherBean@7ea7476f, anotherBean1=springzhuru.AnotherBean@7ea7476f, anotherBean2=springzhuru.AnotherBean@7ea7476f, stringList=[222, 111]]

    222

    111

    List注入方式:如果一个Bean有一个List类型的属性需要注入,spring会到上下文中(扫描注解类)查找所有该List中定义泛型的所有实例(带有@Bean),然后将所有实例注入到List里面。

    @Qualifier("stringList")指定Id,而且在集合属性的set方法上的@Qualifier(“stringList”)指定Id。

    拓展:@Order(数值),来控制实例化Bean的顺序,小的先注入。前提:Spring4.2版本以后该注解才起作用,可以通过它实现注入集合中数据的顺序。

    Map注入

    步骤1:创建Map类型的集合,并提供set方法

    public class MyBean {

     private Map<String,Integer> getIntegerMap;

    @Resource("map")

    public void setGetIntegerMap(Map<String, Integer> getIntegerMap) {

    this.getIntegerMap = getIntegerMap;

    }

    public Map<String, Integer> getGetIntegerMap() {

    return getIntegerMap;

    }

    }
    步骤2:扫描配置文件中提供返回map集合的方法。


    @Bean("map")

    public Map<String,Integer> integerMap(){

    Map<String,Integer> map=new HashMap<String,Integer>();

    map.put("aaa", 111);

    map.put("bbb", 222);

    map.put("ccc", 333);

    return map;

    }

    测试:


    @Test

    public void test(){

    ApplicationContext ac=new AnnotationConfigApplicationContext(MyConfiguration.class);

    MyBean myBean=ac.getBean("myBean",MyBean.class);

    System.out.println(myBean);

    for(Entry<String,Integer> entry:myBean.getGetIntegerMap().entrySet()){

    System.out.println(entry);

    }

    }

    Map注入的第二种方式:同List相同,创建多个方法返回Integer类型参数。
    扫描配置类代码:

    @Bean                //该情况下key的值为Bean的名

    public Integer integerMap1(){

    return 444;

    }

    @Bean

    public Integer integerMap2(){

    return 555;

    }

    结果:还可以通过给@Bean(name="名称")来给实例取名。

    springzhuru.MyBean@11de0733

    integerMap1=444

    integerMap2=555

    四、String、Integer等简单类型的注入

    步骤1:创建简单数据类型的变量,并提供set方法,并在set方法上添加

    @value(“值”)注解。

    public class MyBean {

    private String string;

    public String getString() {

    return string;

    }

    @Value("2222")

    public void setString(String string) {

    this.string = string;

    }

    }

    测试:

    @Test

    public void test(){

    ApplicationContext ac=new AnnotationConfigApplicationContext(MyConfiguration.class);

    MyBean myBean=ac.getBean("myBean",MyBean.class);

    System.out.println(myBean);

    }


    结果:MyBean [string=2222]

    五、SpringIoC容器内置接口实例注入

    private ApplicationContext context;

    //这种情况下,可以直接使用ApplicationContext方法

    public ApplicationContext getContext() {

    return context;

    }

    @Autowired

    public void setContext(ApplicationContext context) {

    this.context = context;

    }

    拓展:除了可以将ApplicationContext注入进来,还可以将BeanFactory、Environment、ResourceLoader、ApplicationEventPublisher、MessageResource及其实现类。

  • SpringIOC注解基本使用(spring2.5后支持注解来管理javaBean)

    @Configuration:该注解标识在类上,然后就可以通过AnnotationConfigApplicationContext(***.class)来获取spring上下文环境(相当于xml的功能)。

    @Bean:与xml配置文件<bean>标签一个用处,<bean>标签的id相当于获得@Bean(name="Id名"),

    如果不使用name,Id名为方法名称。

    @Component:告知spring管理这个类,还可以通过该注解的value属性指定Bean的Id。

    @Controller:被标注在Controller层。

    @Service:被标注在Service层。

    @Repository:被标注在Dao层

    与Spring.xml相比不同点:

    1、不用配置xml文件

    2、提供一个配置类,并采用注解,来获取Bean

    3、获取spring上下文的对象不同,注解使用AnnotationConfigApplicationContext(***.class)获取spring上下文。

    步骤1:提供一个配置类,并在类上添加@Configuration注解,并提供一个返回Bean对象的方法,并在该方法上添加注解。(如果@Bean没指定name属性,则Id为方法名)

    步骤2:提供一个要创建的Bean的类。

    如何进行简化:当要获取多个Bean时,则要编写多个@Bean注解和获取Bean方法?

    步骤1:在配置类中添加@ComponentScan(value=“扫描的路径”)注解。

    @ComponentScan()注解的作用:扫描带有注解@Component的Class,Spring将管理这些Class。

    步骤2:Bean的类上加注解@Component,它的Bean的Id是类名的首字母小写的全称,如果不想使用这种方式,则使用@Component(value=“Id名”)。

    spring.xml中开启包扫描:<context:component-scan base-package="扫描的包路径"/>

    如何给Bean取别名(一个Bean对应多个Id名)?

    因为Bean()注解里的name属性是String类型的数组,所以可以通过它来指定Bean的多个Id。注意:@Component里的value是字符串类型,只能有一个BeanId。

    spring.xml给Bean取别名?

    <bean id="bean1" name="bean2,bean3" class="..."/>

    <alias name="bean1"  alias="bean4"/>

  • Bean属性继承

    应用场景:

    场景一:ParentClass(属性1,属性2,属性3,get和set方法)

    子类1(属性4,属性5) 

    子类2(属性6,属性7)

    场景2:子类1和子类2没有父类,而是有一些相同的属性。

    类1:(属性1,属性2,属性3,属性4,属性5)

    类2:(属性1,属性2,属性3,属性6,属性7)

    这两个场景下,通过Spring注入类1和类2的所有属性,一般如下:

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

    abstract="true":设置<bean>标签只是定义性的,不会对它进行实例化操作。

    parent属性:在Bean的子类bean标签添加,值为父类的Id。

    Spring配置代码:


      <!-- 如果Class1和Class2属性1、2、3相同 -->

    步骤1: <bean id="bean" class="main.java.com.Bean继承属性.ParentClass" abstract="true">

                 <property name="attribute1" value="attribute1"></property>

                 <property name="attribute2" value="attribute2"></property> 

                 <property name="attribute3" value="attribute3"></property>

                 </bean>

     步骤2:    <bean id="bean1" class="main.java.com.Bean继承属性.Class1" parent="bean">

                     <property name="attribute4" value="attribute4"></property>

                     <property name="attribute5" value="attribute5"></property>

                     </bean>   

                     

    <bean id="bean2" class="main.java.com.Bean继承属性.Class2" parent="bean">

            <property name="attribute6" value="attribute6"></property>

            <property name="attribute7" value="attribute7"></property>

            </bean>

           

    测试:


    @Test

    public void test(){

    ApplicationContext ac=new ClassPathXmlApplicationContext("spring-extends.xml");

    Class1 c1=ac.getBean("bean1", Class1.class);

    Class2 c2=ac.getBean("bean2",Class2.class);

    System.out.println(c1);

    System.out.println(c2);

    }

    结果:

    Class1 [attribute1=attribute1, attribute2=attribute2, attribute3=attribute3, attribute4=attribute4, attribute5=attribute5]

    Class1 [attribute1=attribute1, attribute2=attribute2, attribute3=attribute3, attribute6=attribute6, attribute7=attribute7]

    应用场景2:类1和类2不继承某一父类,只是存在相同属性。

    spring配置:


     <!-- 如果Class1和Class2属性1、2、3相同 -->

         步骤1:   <bean id="bean" abstract="true">

             <property name="attribute1" value="attribute1"></property>

            <property name="attribute2" value="attribute2"></property> 

            <property name="attribute3" value="attribute3"></property>

            </bean>

          步骤2:  <bean id="bean1" class="main.java.com.Bean继承属性.Class1" parent="bean">

            <property name="attribute4" value="attribute4"></property>

            <property name="attribute5" value="attribute5"></property>

            </bean>   

            <bean id="bean2" class="main.java.com.Bean继承属性.Class2" parent="bean">

            <property name="attribute6" value="attribute6"></property>

            <property name="attribute7" value="attribute7"></property>

            </bean>        






  • Bean初始化及销毁逻辑处理(在singleton作用域上进行讲解)

    Bean初始化——如果需要在Bean实例化时执行一些逻辑,Spring提供了两种方法:(有一个javaBean,该Bean作用,连接数据库,例如session,断开数据库连接,该Bean被创建之后,执行数据库连接的过程)

    方法1:bean标签里的init-method属性,该值为Bean的某一方法,Spring实例化时,会调用Bean的该方法。

    方法2:让Bean实现InitializingBean接口,Spring在实例化该Bean时,检测到Bean实现了该接口,就会调用该接口所定义的相应方法。

    Bean销毁——如果需要在Bean销毁之前执行一些逻辑,有两种方法。

    方法1:bean标签里的destory-method属性,该值为Bean的某一方法,Spring销毁该Bean时,会调用Bean的该方法。

    方法2:让Bean实现DisposableBean接口,Spring在销毁该Bean时,检测到Bean实现了该接口,就会调用该接口所定义的相应方法。

    案例1:通过bean标签的init-method和destory-method属性来指定Bean初始化逻辑和销毁逻辑。

    代码:

    public class Bean {

    public void onInit(){

    System.out.println("Bean的初始化逻辑方法被执行了");

    }

    public void onDestory(){

    System.out.println("Bean的销毁逻辑方法被执行了");

    }

    }

    测试代码:

    @Test

    public void test(){

    ApplicationContext ac=new ClassPathXmlApplicationContext("spring-initAnddestory.xml");

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

    System.out.println(bean);

    }

    结果:bean的销毁方法没执行,因为当前是单例模式,所以Bean的初始化是在Spring上下文实例化完成的,Bean的销毁是在Spring上下文的销毁过程中执行Bean的销毁。(Spring上下文的销毁定义到AbstractApplicationContext中)

    Bean的初始化逻辑方法被执行了

    main.java.com.Bean初始化及销毁.Bean@b8a1063

    spring配置:

    <bean class="main.java.com.Bean初始化及销毁.Bean" id="bean" init-method="onInit" destroy-method="onDestory">

    改进:

    @Test

    public void test(){

    AbstractApplicationContext ac=new ClassPathXmlApplicationContext("spring-initAnddestory.xml");

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

    System.out.println(bean);

    ac.close();

    }

    注意:如果所有的Bean都有相同名称的初始化方法和相同名称的销毁方法,可以在<beans default-init-method="onInit"   default-destory-method="onDestory">,含义:所有的bean都有初始化方法和销毁方法。

    案例2:实现相应接口,并实现相应方法

    代码:

    public class Bean implements InitializingBean,DisposableBean{

    @Override

    public void destroy() throws Exception {

    System.out.println("Bean的销毁逻辑方法被执行了");

    }

    @Override

    public void afterPropertiesSet() throws Exception {

    System.out.println("Bean的初始化逻辑方法被执行了");

    }

    }

    spring配置:

    <bean class="main.java.com.Bean初始化及销毁.Bean" id="bean"></bean>

    测试:

    @Test

    public void test(){

    AbstractApplicationContext ac=new ClassPathXmlApplicationContext("spring-initAnddestory.xml");

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

    System.out.println(bean);

    ac.close();

    }


首页上一页1234567下一页尾页

举报

0/150
提交
取消
课程须知
需要具备Java语法基础,了解Java Web基础知识。
老师告诉你能学到什么?
1、什么是IoC 2、Spring Bean的管理 3、什么是懒加载

微信扫码,参与3人拼团

意见反馈 帮助中心 APP下载
官方微信
友情提示:

您好,此课程属于迁移课程,您已购买该课程,无需重复购买,感谢您对慕课网的支持!