spring01

                                                                   spring的体系结构图

第一个spring入门例子

01.创建一个java项目 引入所需要的jar包

02.创建对应的包和类

Animal接口对应的代码

public interface Animal {

    String  eat(); //吃饭
    void sleep();  //睡觉
}

Dog类对应的代码

public class Dog implements Animal {

//无参构造 验证什么时候创建对象
public Dog(){
System.out.println("Dog的实例被创建了......");
}

@Override
public String eat() {
System.out.println("吃饭的方法");
return null;
}

@Override
public void sleep() {
System.out.println("睡觉的方法");
}

}

AnimalText对应的代码

public class AnimalTest {
    
    @Test
    public  void  test01(){
        //之前的一种方式    耦合的！
        Animal animal=new Dog();
        animal.eat();
        animal.sleep();
    }
}

03.使用spring解耦的方式 创建applicationContext.xml文件 放在src的根目录下

<?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">

    <!-- bean definitions here  我们的bean要定义在这个地方 -->
    <bean id="dog" class="cn.bdqn.dao.impl.Dog"/>
</beans>

 04.在AnimalTest测试类中增加代码

@Test
    public  void  test02(){
        /*
         * 使用spring  对象交给容器来创建 解耦
         * 01.引入jar
         * 02.创建容器applicationContext.xml
         * 03.加载spring的配置文件  创建容器   会把容器中所有的bean实例化   
         * 04.然后从容器中取Bean
         */
      ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
      System.out.println("*************************");
        //因为我们在容器中定义了ID  根据id找到对应的类 
      Animal dog=(Animal) context.getBean("dog");
      dog.eat();
      dog.sleep();
    }

为什么 使用new ClassPathXmlApplicationContext来创建容器对象，由源码得知：

05.在AnimalTest测试类中增加代码   使用其他的方式来创建容器

@Test
    public  void  test03(){
        /*
         * 使用new FileSystemXmlApplicationContext来创建对象
         * 默认applicationContext.xml放在项目的根路径下面
         * 也可以放在电脑指定的盘符下d:/applicationContext.xml
         */
        ApplicationContext context=new FileSystemXmlApplicationContext("applicationContext.xml");
        System.out.println("*************************");
        //因为我们在容器中定义了ID  根据id找到对应的类 
        Animal dog=(Animal) context.getBean("dog");
        dog.eat();
        dog.sleep();
    }
    
    
    @Test
    public  void  test04(){
        /*
         * 使用BeanFactory来创建容器的时候，不会实例化容器中的Bean
         * 在getBean()才创建对应Bean的对象
         */
        BeanFactory context=new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
        System.out.println("*************************");
        //因为我们在容器中定义了ID  根据id找到对应的类 
        Animal dog=(Animal) context.getBean("dog");
        dog.eat();
        dog.sleep();
    }

06.使用动态工厂来创建指定的对象

       001.创建一个AnimalFactory工厂类

public class AnimalFactory {  //动态工厂
    
    public  AnimalFactory(){
        System.out.println("工厂的无参构造........");
    }
    
    //当调用这个方法的时候  返回一个 Dog对象
    public  Animal getDog(){
        System.out.println("工厂中获取Dog实例的方法");
        return new Dog();
    }

}

002.修改applicationContext.xml文件 之前的代码注释掉

<!-- 使用动态工厂创建对象 -->
    <bean id="factory"  class="cn.bdqn.test.AnimalFactory"/>
    <!-- 通过 工厂的指定方法 来得到指定的对象 -->
    <bean id="dog" factory-bean="factory" factory-method="getDog"/>

003.在AnimalTest测试类中创建对应的测试方法

//使用动态工厂来创建对象
    @Test
    public  void  test05(){
      ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
      System.out.println("*************************");
        //因为我们在容器中定义了ID  根据id找到对应的类 
      Animal dog=(Animal) context.getBean("dog");
      dog.eat();
      dog.sleep();
    }

07.使用静态的工厂来创建指定的对象

    001.修改上面创建的AnimalFactory类  把之前的getDog()注释掉

//静态工厂    不会走无参构造
    public   static  Animal getDog(){
        System.out.println("工厂中静态获取Dog实例的方法");
        return new Dog();
    }

002.修改applicationContext.xml文件  之前的代码注释掉

<!--使用静态工厂创建对象   -->
    <bean id="dog" class="cn.bdqn.test.AnimalFactory" factory-method="getDog"/>

003.在AnimalTest测试类中创建对应的测试方法

//使用静态工厂来创建对象
    @Test
    public  void  test06(){
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        System.out.println("*************************");
        //因为我们在容器中定义了ID  根据id找到对应的类 
        Animal dog=(Animal) context.getBean("dog");
        dog.eat();
        dog.sleep();
    }

08.bean的单例和原型

    001.修改applicationContext.xml文件

 <!--bean的单例和原型
     singleton： 默认的方式创建bean,单例 在容器初始化的时候就创建了 对应的Bean对象
     prototype: 原型！ 只有在需要对象(getBean())的时候会创建一个新的对象！
   -->
    <bean id="dog" class="cn.bdqn.dao.impl.Dog"  scope="prototype"/>

    002.在AnimalTest测试类中新增测试方法

//bean的单例和原型
    @Test
    public  void  test07(){
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        System.out.println("*************************");
        //获取两个对象  咱们观察  什么时候 执行  无参构造 
        Animal dog=(Animal) context.getBean("dog");
        Animal dog2=(Animal) context.getBean("dog");
    }

003.执行代码 看效果

    scope="prototype"时：效果图如下

 scope="singleton"，或者不写scope属性时：效果图如下

09.设置bean的生命始末

  001.在Dog类中新增两个方法

//初始化之后的方法
    public void  init(){
        System.out.println("初始化之后的方法");
    }
    
    //销毁之前的方法
    public void  destroy(){
        System.out.println("销毁之前的方法");
    }

002.在applicationContext.xml文件中配置

<!--设置bean的生命周期始末  -->
    <bean id="dog" class="cn.bdqn.dao.impl.Dog" init-method="init" destroy-method="destroy"/>

003.在AnimalTest测试类中新增测试方法

/*
     * 设置bean的生命周期始末
     * 01.在Dog类中新增两个方法  init()　destroy()
     * 02.在容器中 配置
     *    init-method="init" destroy-method="destroy"
     */
    @Test
    public  void  test08(){
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        System.out.println("*************************");
        Animal dog=(Animal) context.getBean("dog");
        System.out.println(dog);
        /*
         * 想看到destroy-method="destroy" 的效果 有两个前提
         * 01.bean必须是单例的
         * 02.容器需要手动的关闭
         */
        ((ClassPathXmlApplicationContext)context).close();
    }