Spring入门

1.Spring 简介

Spring的基础架构起源于2000年早期，它是Rod Johnson在一些成功的商业项目中构建的基础设施

2002后期，Rod Johnson发布了《Expert One-on-One J2EE Design and Development》一书

2003年2月Spring框架正式成为一个开源项目，并发布于SourceForge中

1.2 Spring工作原理

Spring是一种用JavaBean配置应用程序的方法

运用SpringIOC，通过setter方法来暴露一个类的任何依赖关系（如一个数据库连接），只要在Spring中进行配置来解决依赖性，不用编写一个数据库连接

运用Spring AOP 可以解决公共代码重复问题

1.3 Spring框架简介

Spring框架

轻量级

容器

开源框架

用于解决企业应用程序开发复杂性

一个轻量级的IOC和AOP容器框架

一个解决了许多J2EE开发中常见的问题的强大框架

1.4 Spring框架简介

Spring框架有7个模块， 每个模块都可以单独存在，或者与其他一个或多个模块联合实现

2.1 Spring Bean 封装机制

Spring以Bean的方式管理所有的组件，J2EE的全部组件都被视为Bean管理

Spring负责创建Bean的实例，并管理其生命周期

Bean在Spring的容器中运行，无须知道Spring容器的存在也可以使用Spring的一些特性

<?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-3.0.xsd">
    <bean id=“user" class="com.hr.g3.persist.UserVo"
        abstract="false" lazy-init="default" autowire="default"
        dependency-check="default">
    </bean> 
</beans>

<bean
id="beanId"
name ="beanName"
class="beanClass"
parent="parentBean"
abstract="true ｜ false"
scope="prototype|singleton"
lazy-init="true ｜ false ｜ default"
autowire="no ｜ byName ｜ by Type ｜ constructor ｜ auto detect ｜default">
</ bean>

BeanFactory

BeanFactory由org.springframework.beans.factory.BeanFactory接口定义

BeanFactory是工厂模式（Factory pattern）的实现，负责创建和管理bean

BeanFactory接口包含以下基本方法

containsBean(String name)

getBean(String name)

getBean(String name,Class class)

getType(String name)

ApplicationContext

ApplicationContext是基于BeanFactory之上的，提供了应用程序框架服务，扩展的新功能如下

提供国际化的支持

资源访问，如URL和文件

事件传递

载入多个配置文件等

搜索classpath路径，以classpath路径下的applicationContext.xml和bean.xml创建ApplicationContext

ApplicationContext applicationContext = new ClassPathXmlApplicationContext(“applicationContext.xml”);//单个文件


BeanFactory beanFactory = new ClassPathXmlApplicationContext(new String[]{“applicationContext.xml”,“bean.xml”}); //多个文件

按照指定路径下的applicationContext.xml和bean.xml创建ApplicationContext

BeanFactory beanFactory = 
new FileSystemXmlApplicationContext(
new String[]{
"/WebRoot/WEB-INF/classes/applicationContext.xml",
"/WebRoot/WEB-INF/classes/bean.xml"});

ApplicationContext接口的重要方法

(1)containsBean(String name)方法。
//判断Spring容器是否包含ID为 user的Bean
boolean flag=applicationContext.containsBean("user");

(2)getBean(String name)方法。
//返回ID为 user的Bean
UserVo userBean= (UserVo)applicationContext.getBean("user");


(3)getType(String name)方法
//返回:ID为 user 的类型
Class beanType= applicationContext.getType("user");

3.Spring依赖注入 （非注解）

设值注入的优点

如果依赖关系（或继承关系）较为复杂 ，设值注入模式往往更为简洁 有些地方有其局限性

直观，更加自然

构造注入的优点

构造期即创建一个完整、合法的对象

避免了繁琐的setter方法的编写

无需担心在调用过程中执行setter方法对组件依赖关系产生破坏

在构造函数中决定依赖关系的注入顺序

自动注入

简化配置文件

3.1接口与实体类

package cn.yunhe.entity;

/**
 * Created by Administrator on 2017/7/11.
 */
public interface Display {
    void printDisplayInfo();

}

package cn.yunhe.entity;

/**
 * Created by Administrator on 2017/7/11.
 */
public class Computer {
    private MainFrame mainFrame;//主机
    private Display display;//显示器接口

    public Computer() {
    }

    public Computer(MainFrame mainFrame, Display display) {
        this.mainFrame = mainFrame;
        this.display = display;
    }

    //输出计算机配置信息
    public void printComputerInfo(){
        System.out.println("计算机配置如下：");
        mainFrame.printMainFrameInfo();//输出主机信息
        display.printDisplayInfo();//输出显示器信息

    }

    public MainFrame getMainFrame() {
        return mainFrame;
    }

    public void setMainFrame(MainFrame mainFrame) {
        this.mainFrame = mainFrame;
    }

    public Display getDisplay() {
        return display;
    }

    public void setDisplay(Display display) {
        this.display = display;
    }
}

package cn.yunhe.entity;

/**
 * Created by Administrator on 2017/7/11.
 */
public class LgDisplay  implements Display{

    //LG显示器
    public void printDisplayInfo() {
        System.out.println("显示器：LG显示器");
    }
}

package cn.yunhe.entity;

/**
 * Created by Administrator on 2017/7/11.
 */
public class MainFrame {
    private String modelType; //型号
    //输出主机信息
    public void printMainFrameInfo(){
        System.out.println("主机型号："+modelType);
    }

    public String getModelType() {
        return modelType;
    }

    public void setModelType(String modelType) {
        this.modelType = modelType;
    }
}

package cn.yunhe.entity;

/**
 * Created by Administrator on 2017/7/11.
 */
public class SamSungDisplay implements Display{

    //三星显示器
    public void printDisplayInfo() {
        System.out.println("显示器：三星显示器");
    }
}

package cn.yunhe.entity;

import java.util.*;

/**
 * Created by Administrator on 2017/7/11.
 */
public class TestBean {
    private List list;
    private Map map;
    private Properties prop;
    private Set set;

    public List getList() {
        return list;
    }

    public void setList(List list) {
        this.list = list;
    }

    public Map getMap() {
        return map;
    }

    public void setMap(Map map) {
        this.map = map;
    }

    public Properties getProp() {
        return prop;
    }

    public void setProp(Properties prop) {
        this.prop = prop;
    }

    public Set getSet() {
        return set;
    }

    public void setSet(Set set) {
        this.set = set;
    }
}

package cn.yunhe.entity;

/**
 * Created by Administrator on 2017/7/11.
 */
public class UserVo {
    private int id;
    private String name;
    private int age;

    public void printInfo(){
        System.out.println("姓名："+name+",年龄："+age);
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

3.2配置文件

<?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:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

    <context:component-scan base-package="cn.yunhe.entity"/>
    <bean id="user" class="cn.yunhe.entity.UserVo"/>
    <bean id="mainFrame" class="cn.yunhe.entity.MainFrame">
        <property name="modelType" value="三星高配主机"/>
    </bean>
    <bean id="lg" class="cn.yunhe.entity.LgDisplay"/>
    <bean id="samsung" class="cn.yunhe.entity.SamSungDisplay"/>

    <!--设值注入是指通过setter方法传入被调用者的实例-->
    <!--<bean id="computer" class="cn.yunhe.entity.Computer">
        <property name="mainFrame" ref="mainFrame"/>
        <property name="display" ref="lg"/>
    </bean>-->
    <!--构造注入是指通过构造方法完成依赖关系的注入-->
    <bean id="computer2" class="cn.yunhe.entity.Computer">
        <constructor-arg index="0" ref="mainFrame"/>
        <constructor-arg index="1" ref="samsung"/>
    </bean>

    <!--Spring容器可以自动注入（autowire）相互协作bean之间的关联关系-->
    <!--no : 不适用自动的装配，必须通过ref元素指定依赖。这是默认设置。
            由于显式指定协作者可以使配置更灵活、更清晰，因此对于较大的
            部署配置，推荐采用该设置。-->
    <!--byName :根据属性名自动装配。此选项将检查容器并根据名字查找与属
                性完全一致的bean，并将其与属性自动装配-->
    <!--byType :如果容器中存在一个与指定属性类型相同的bean，那么将与该
                属性自动装配。如果存在多个该类型的bean，那么将会抛出异
                常，并指出不能使用byType方式进行自动装配。若没有找到相
                匹配的bean，则属性不会被设置。-->
    <bean id="computer" class="cn.yunhe.entity.Computer" autowire="byName">
        <property name="display" ref="lg"/>
    </bean>

    <!--集合属性-->
    <bean id="testBean" class="cn.yunhe.entity.TestBean">
        <property name="list">
            <list>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
            </list>
        </property>
        <property name="map">
            <map>
                <entry key="k1" value="v1"/>
            </map>
        </property>
        <property name="prop">
            <props>
                <prop key="k1" >str1</prop>
            </props>
        </property>
        <property name="set">
            <set>
                <value>ddd</value>
                <value>eee</value>
            </set>
        </property>
    </bean>
</beans>

3.3 测试类

package cn.yunhe.demo;

import cn.yunhe.entity.Computer;
import cn.yunhe.entity.TestBean;
import cn.yunhe.entity.UserVo;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.List;

/**
 * Created by Administrator on 2017/7/11.
 */
public class Demo {

    ApplicationContext applicationContext =null;
    @Before
    public void init(){
        //以classpath路径下的applicationContex.xml创建Spring容器
        applicationContext =new ClassPathXmlApplicationContext("applicationContext.xml");
    }

    @Test
    public void test1(){
        //从Spring容器中获取ID 为user的Bean
        UserVo user=applicationContext.getBean("user",UserVo.class);
        //封装姓名和年龄
        user.setName("张三丰");
        user.setAge(100);
        //输出该bean的信息
        user.printInfo();
    }

    @Test//Spring的设值注入方式    //自动注入也有用这个例子
    //设值注入是指通过setter方法传入被调用者的实例
    public void test2(){
      Computer computer=  applicationContext.getBean("computer", Computer.class);
        computer.printComputerInfo();
    }

    @Test//Spring的构造注入方式
    //构造注入是指通过构造方法完成依赖关系的注入
    public void test3(){
        Computer computer=applicationContext.getBean("computer2",Computer.class);
        computer.printComputerInfo();
    }

    @Test//集合属性
    public void test4(){
        TestBean testBean=applicationContext.getBean("testBean",TestBean.class);
        List<String>list = testBean.getList();
        for (String str:list){
            System.out.println(str);
        }
    }

}

 4.注解实现Spring注入

@Component 注解配置bean @Component注解唯一的一个可选参数是value，用于指定bean的名称(即id值，所以必须是唯一的)

@Component(”computer”)
public class Computer { }
@Component
public class MainFrame {}
@Component
public class SamSungDisplay implements Display {}
@Component
public class LgDisplay implements Display {}

 只需在配置文件中配置以下代码     扫描@Component标注的类

<context:component-scan 
base-package="s3spring.ch1.annotation.computer"/>

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

//从容器获取bean
Computer c = ac.getBean(Computer.class);

使用 @Scope注解配置bean 的作用域

@Scope定义bean的作用域，singleton表示在Spring loC容器中一个bean的定义对应一个对象实例，Spring使用单例模式获取实例

     prototype 表示一个bean定义对应多个对象实例，即非单例模式，常称作多例

@Component
@Scope(value="prototype")
public class Computer { …… }

使用@Autowired注解  

　　可以对类成员变量、方法及构造函数进行标注，以完成自动装配依赖的工作

　　 @Autowired 默认按 byType 自动注入

@Component
@Scope("prototype")
public class Computer {
@Autowired
private MainFrame mainFrame;// 主机
@Autowired
private Display display;// 显示器接口
……

多个bean导致的创建bean失败的问题

把属性名称做为依赖bean名称

@Qualifier 注解明确指定依赖bean的名称（就是显示器接口被多个类实现，导致使用该接口时不知道调那个类，就需要在这里声明一下）

@Component
@Scope("prototype")
public class Computer {
@Autowired
private MainFrame mainFrame;// 主机
@Autowired
@Qualifier("samSungDisplay")//表明是用的三星的
private Display display;// 显示器接口
    ……
}

注解的运行流程

1.首先根据属性的类型在Spring 应用容器中查找类型匹配的bean

2.如果没有类型匹配的bean，抛出BeanCreationException；如果只有一个，则注入依赖，完成自动装配；如果不只一个，则继续执行步骤3；

3.如果通过 @Qualifier指定了bean 名称，则从所有符合类型的bean中返回指定的bean，完成自动装配；如果没有通过 @Qualifier制定bean 名称，则通过反射技术获取当前属性的名称作为bean 名称返回指定的bean，完成自动装配；

 

使用@Resource注解注入依赖   

@Resource 默认按 byName 自动注入    用法与上边使用@Autowire相同

@Component
@Scope("prototype")
public class Computer {
    @Resource
    private MainFrame mainFrame;//采用属性名称作为依赖bean的名称
 
    @Resource(name="samSungDisplay")
    private Display display;// 采用@name参数值作为依赖bean的名称
     ……
}

使用JSR-250规范定义的注解

@PostConstruct 和 @PreDestroy

@PostConstruct 注解的方法将在类实例化后调用，

@PreDestroy注解的方法将在类销毁之前调用 ConfigurableApplicationContext close方法

@PostConstruct
public void postConstruct1(){
         System.out.println("执行postConstruct1");
}
 
@PreDestroy
public void preDestroy1(){
         System.out.println("执行preDestroy1"); 
}