spring概述、容器、set方法注入依赖关系

一.spring是什么?

• 是一个开源的,轻量级的,用来简化应用开发的框架.

1.简化开发

• 例如:简化jdbc的模块-spring jdbc只需要写一两行代码就可以实现java数据库的连接,而且代码质量及高.
  当然spring不仅对jdbc做了封装,而且对常用的API做了封装和简化.
  使用spring jdbc来访问数据库就不需要咋考虑获取连接和关闭连接了.

2.管理对象

• 不管这个程序有多大,都是一系列对象在相互调用而已.当一个程序复杂就是对象比较多.
  spring提供了一个容器,帮我们创建对象以及建立对象之间的依赖关系.这样做的好处是降低对象之间的耦合度方便代码的维护.

3.集成其它框架

• 任务调度的框架 Quartz,spring没有这个框架但是可以利用Spring把它进行集成. spring的设计思想:不发明重复的轮子
• 一站式的框架,就是一个就够了.

二.spring容器

1.Spring容器是什么?

• 是Spring框架中的一个最核心的模块,用于管理对象.包括对象的销毁,创建,和依赖关系等.

2.启动Spring容器?

• step1. 导包.(spring-webmvc)
• step2. 添加配置文件.applicationContext.xml
• step3. 启动spring容器.
• 出现问题:Description Resource Path Location Type
  Archive for required library: ‘C:/Users/wangzhongjie/.m2/repository/org/springframework/spring-beans/3.2.8.RELEASE/spring-beans-3.2.8.RELEASE.jar’ in project ‘Spring1’ cannot be read or is not a valid ZIP file Spring1 Build path Build Path Problem

3.如何创建对象?

• java反射机制

• 方式一 使用无参构造器(重点)

  • step1.各类添加无参构造器(或者缺省构造器).
  • step2.配置元素
  • step3.调用容器的一个方法getBean来获得对象.

• 方式二 使用静态工厂方法(了解)

  • 通过调用类的静态方法来创建一个对象.

• 方式三 使用实例工厂方法(了解)

  • 通过调用对象的实例方法来创建对象.

4.作用域

• 默认情况下,容器对于某个bean,只会创建一个实例.

ApplicationContext ac = new ClassPathXmlApplicationContext("scope.xml");
        ScopeBean s1  = ac.getBean("s1",ScopeBean.class);
        ScopeBean s2 = ac.getBean("s1",ScopeBean.class);
        System.out.println(s1 == s2);

• 可以设置scope属性值为prototype,这样容器对于某个bean会创建多个实例.

    <!-- 
        scope属性:配置作用域,缺省值是singleton(单例模式)
        singleton(即一个bean只创建一个实例),如果prototype(即一个bean会创建多个实例).
        既是调用几个getBean()方法它就会创建几个
     -->
     <bean id="s1" class="scope.ScopeBean" scope="prototype"></bean>

5.生命周期

• 初始化方法:init-method属性来指定初始化方法名.
  

  spring容器创建对象之后会立即调用初始化方法.

    <!-- 
        init-method属性:用来指定初始化方法.
        spring容器会创建mb1对象,然后会立即调用init方法完成初始化.
      -->
      <bean id="mb1" class="scope.MessageBean" init-method="init"/>

• 销毁方法:使用destroy-method属性来指定销毁方法名,
  

  spring容器在关闭之前,会销毁对象,在销毁对象之前,会先调用对象的销毁方法,只有作用域为单利的时候,销毁方法才起作用.

    ublic static void main(String[] args) {
        //启动Spring容器
        //ApplicationContext:接口
        //AbstractApplicationContext:上面接口的子接口
        //ClassPathXmlApplicationContext:实现了上述接口具体类
        AbstractApplicationContext ac = new ClassPathXmlApplicationContext("scope.xml");
        //获得对象
        MessageBean mb1 = ac.getBean("mb1",MessageBean.class);
        mb1.sendMsg();
        //关闭容器
        ac.close();
    }

    <!-- 
        init-method属性:用来指定初始化方法.
        spring容器会创建mb1对象,然后会立即调用init方法完成初始化.
        destroy-method属性:用来执行销毁方法
        当我们把容器给关闭的时候会销毁对象
      -->
      <bean id="mb1" class="scope.MessageBean" init-method="init" destroy-method="destroy"/>

6.延迟加载(了解)

• Spring容器启动之后,会将所有作用域为单例的bean创建好.并且会调用初始化方法.
• 指定lazy-init属性值为true,此时,spring容器对于作用为单例的bean不会再创建响应的实例.
  <bean id="mb1" class="scope.MessageBean" init-method="init" destroy-method="destroy" lazy-init="true"/>

三.IOC(Inversion Of Control 控制反转)

1.什么是IOC?

• 含义:对象之间的依赖关系,由容器来建立.

2.DI(Dependency Injection 依赖注入)是什么?

• 容器通过调用对象提供的set方法或者构造器来建立依赖关系.
  

  注:IOC是目标,DI是手段.
  
  

• 实例代码

package ioc;

public class B {
    public B() {
        System.out.println("B()");
    }
    public void f1() {
        System.out.println("B's f1()");
    }
}

package ioc;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class A {
    private B b;

    public B getB() {
        return b;
    }
    public void setB(B b) {
        System.out.println("setB()");
        this.b = b;
    }
    public A() {
        System.out.println("A()");
    }
    public void execute() {
        System.out.println("execute()");
        b.f1();
    }
    //测试set方式的注入
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("ioc.xml");
        A a1 = ac.getBean("a1",A.class);
        a1.execute();
    }
}

    <bean id="b1" class="ioc.B"/>
        <!-- 
            property元素:表示使用set方法来注入依赖关系.
            其中,name属性指定属性名,ref属性指定属性值(是被注入的bean的id).
            name="b",就会调用setB()方法,会把b大写然后加上set
         -->
        <bean id="a1" class="ioc.A">
            <property name="b" ref="b1"/>
     </bean>

set注入示例

• 接口IB

package ioc;

public interface IB {
    public void f1();
}

• 类B

package ioc;

public class B implements IB{
    public B() {
        System.out.println("B()");
    }
    public void f1() {
        System.out.println("B's f1()");
    }
}

• 类C

package ioc;

public class C implements IB{
    public C() {
        System.out.println("C()");
    }
    public void f1() {
        System.out.println("C's f1()");
    }
}

• ioc.xml

    <bean id="c1" class="ioc.C"/>
    <bean id="b1" class="ioc.B"/>
    <bean id="a1" class="ioc.A"> 
        <property name="b" ref="c1"/>
    </bean>

• 类A加载测试主方法

package ioc;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class A {
    private IB b;

    public void setB(IB b) {
        System.out.println("setB()");
        this.b = b;
    }
    public A() {
        System.out.println("A()");
    }
    public void execute() {
        System.out.println("execute()");
        b.f1();
    }
    //测试set方式的注入
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("ioc.xml");
        A a1 = ac.getBean("a1",A.class);
        a1.execute();
    }
}

不需要通过改动源代码就可以实现通过spring器来创建对象,并且可以通过改动xml,配置文件来实现对象的依赖关系