spring框架

Spring

一. Spring是什么?

　　Spring是一个开源的用来简化应用开发的框架。

二. Spring的特点?

　　1)简化开发

　　　　Spring对很多常用的api做了简化（比如，Spring对jdbc就做了很好的 封装，我们利用Springjdbc访问数据库，就不用考虑如何获取连接和关闭 连接）。

　　2)管理对象（解耦）

　　　　Spring帮我们管理对象之间的依赖关系，这样，便于代码的维护。

　　3)集成（其他框架）

　　　　Spring可以集成其它的一些框架。集成之后，这些框架的使用会变得 更加的简单。（将其他框架集成进来）

三 .Spring容器

　　1)Spring容器是什么?

　　　　Spring框架当中的一个核心模块，用来管理对象。

　　2)如何将一个bean组件(普通的java类)交给spring容器?

　　　　在配置文件里添加bean的属性:<bean id ="" class=""></bean>

　　3)如何启动Spring容器?(war)

　　　　step1. 导包。（spring-webmvc  org.springframework..3.2.8）
　　　step2. 添加配置文件。(将bean组件交给spring容器)

　　　　src/main/resources --applicationContext.xml、

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context" 
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"  
    xmlns:jee="http://www.springframework.org/schema/jee" 
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:util="http://www.springframework.org/schema/util"
    xmlns:jpa="http://www.springframework.org/schema/data/jpa"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
        http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">
    <!-- 
        利用无参构造器创建对象。
        id属性：bean的名称，要求唯一。
        class属性：类的全限定名。
     -->
    <bean id="stu1" class="first.Student">
    </bean>
    
    <bean id="date1" class="java.util.Date">
    </bean>
    
    <!-- 使用静态工厂方法创建对象。
        factory-method属性：指定一个静态方法，
        Spring容器会调用这个方法来创建对象。
    -->
    <bean id="cal1" class="java.util.Calendar"
        factory-method="getInstance">
    </bean>
    
    <!-- 使用实例工厂方法创建对象
        factory-bean属性：指定一个bean的id ，
        Spring容器会调用该对象对应的方法
        来创建对象。
     -->
    <bean id="time1" factory-bean="cal1" 
        factory-method="getTime">
    </bean>
    
    
    
</beans>

　　step3. 编写启动Spring容器的代码。

　　　　src/main/java 

package first;

import java.util.Calendar;
import java.util.Date;

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

public class FirstSpring {

    public static void main(String[] args) {
        //step1. 启动Spring容器
13         /*
14          * ClassPathXmlApplicationContext
15          * 会依据类路径查找配置文件。
16          */
17         ApplicationContext ac = 
18         new ClassPathXmlApplicationContext(
19                 "applicationContext.xml");
        //System.out.println(ac);
        //step2. 通过容器，获得对象。  
        Student stu1 = 
                ac.getBean("stu1",Student.class);
        System.out.println(stu1);
        
        Date date1 = 
                ac.getBean("date1",Date.class);
        System.out.println(date1);
        
        Calendar cal1 = 
                ac.getBean("cal1",Calendar.class);
        System.out.println("cal1:" + cal1);
        
        Date time1 = 
                ac.getBean("time1",Date.class);
        System.out.println("time1:" + time1);
    }

}

如何创建对象?

方式一 无参构造器（*）

step1. 给类应用提供无参构造器（或者缺省构造器）。
step2. 在配置文件当中，添加一个bean元素。
step3. 启动Spring容器，调用容器提供的getBean方法获得要创建的 对象。

　　无参构造器（或者缺省构造器）：

package first;

public class Student {

    public Student() {
        System.out.println("Student()");
    }
    
}

　　添加bean元素

<!-- 
23         利用无参构造器创建对象。
24         id属性：bean的名称，要求唯一。
25         class属性：类的全限定名。
26      -->
27     <bean id="stu1" class="first.Student">
28     </bean>

　　获得对象

//step2. 通过容器，获得对象。  
         Student stu1 = 
                 ac.getBean("stu1",Student.class);
         System.out.println(stu1);

 

方式二 静态工厂方法 （了解）

方式三 实例工厂方法 （了解）

生命周期的管理

　　初始化方法 ：
　　　　(用于获取资源,只执行一次)。
　　销毁方法: 
　　　　（用于释放资源，只执行一次）。 
注意，销毁方法只有在作用域为singleton才起作用。 

作用域

　　默认情况下，对于一个bean元素，容器只会创建一个对应的实例。
　　可以设置作用域为prototype(原型，多个实例)。

延迟加载 (了解)

　　默认情况下，当容器启动之后，会将所有作用域为单例的bean创建好。
　　lazy-init属性：如果值为true,表示延迟加载，即容器启动之后，不会立即创建该实例。

package basic;

public class MessageBean {

    public MessageBean() {
        System.out.println("MessageBean()");
    }
    
    public void init(){
        System.out.println("init()");
    }
    
    public void sendMsg(){
        System.out.println("sendMsg()");
    }
    
    public void destroy(){
        System.out.println("destroy()");
    }

}

配置文件

<!-- 
        init-method属性：指定初始化方法。
        destroy-method属性：指定销毁方法。
        lazy-init属性：如果值为true,表示延迟加载，
        即容器启动之后，不会立即创建该实例。 
     -->
    <bean id="mb1" class="basic.MessageBean" 
        init-method="init" 
        destroy-method="destroy"
        lazy-init="true">
    </bean>
    
    <!-- 
        scope属性：指定作用域，缺省值是
        singleton(单例，即单个实例);
        可以设置作用域为prototype(原型，多个实例)。
     -->
    <bean id="sb1" class="basic.ScopeBean"
    scope="prototype">
    </bean>

 

(4)IOC (Inversion Of Controll 控制反转)

什么是IOC？

对象之间的依赖关系由容器来建立。

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

容器通过调用set方法或者构造器来建立对象之间的依赖关系。
注： IOC是目标，而DI是手段。 

依赖注入的两种方式

　　把b注入a：　　1：在a中声明private属性的b变量（private B b）；

　　　　　　　　　2：在a中添加一个setB（）

　　　　　　　　　//3：在a中添加无参构造器

方式一 ：set方法。
step1. 添加set方法。

step2. 配置set方法注入。

 

package ioc;

public class A {
    private B b;
    
    public void setB(B b) {
        System.out.println("A's setB()");
        this.b = b;
    }

    public A() {
        System.out.println("A()");
    }
    
    public void service(){
        System.out.println("A's service()");
        //调用B的f1()方法
        b.f1();
    }

}

package ioc;

public class B {

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

}

 方法二：构造器注入

step1. 添加构造器。

step2. 配置构造器注入。

方法三：自动装配 (了解)

什么是自动装配？

容器依据某些规则，自动建立对象之间的依赖关系。
注：默认情况下，容器禁止自动装配。

注入基本类型的值

使用value属性来注入。

<bean id="vb1" class="value.ValueBean">
        <property name="name" value="小月"/>
        <property name="age" value="22"/>
        <property name="interest">
            <list>
                <value>钓鱼</value>
                <value>旅游</value>
                <value>看电视</value>
                <value>看电视</value>
            </list>
        </property>
        <property name="city">
            <set>
                <value>北京</value>
                <value>长沙</value> 
                <value>南京</value>
            </set>
        </property>
        <property name="score">
            <map>
                <entry key="英语" value="60"/>
                <entry key="math" value="80"/>
            </map>
        </property>
        <property name="db">
            <props>
                <prop key="username">King</prop>
                <prop key="password">1234</prop>
            </props>
        </property>
    </bean>

 

注入集合类型的值

List,Set,Map,Properties 

引用的方式注入集合类型的值

读取properties文件的内容

使用Spring表达式