Spring框架

Spring框架简介

Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。
Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

IOC简介

spring中提供了IOC容器，即IOC（Inversion Of Control）控制反转，所谓控制反转就是说将对象的创建交给外部容器完成，这个就是控制反转。
spring中使用控制反转来实现对象在不同程序中的使用。而容器存在的必要性就是管理对象。

我们以一个购买图书的场景来分析使用Java实例，使用相关对象是需要new创建并持有，它会存在以下缺点。
1、实例化一个组件会比较困难，两个对象都需要创建数据源，读取配置，谁来创建和处理等都是一个问题。
2、很多组件需要销毁来释放资源，采用共享的方式，不好确保正确销毁。
3、随着映入到的业务组件越来越多，对组件的共享管理也就越来越复杂。

Spring可以提供IOC容器，来管理所有的组件(对象)，所有的对象的创建、销毁都交给容器，谁需要使用对象，在容器中获取该对象的使用权，哪一个对象需要，就将使用的对象注入到该对象，对于使用方而言，只需要关注使用即可，而对象的生命周期的管理就交给IOC容器 进行管理。

IOC容器负责实例化所有的组件，需要进行 依赖的对象都交给容器管理，IOC最简单的方式就是通过xml方式

<beans> 
  数据源交给容器管理
  <bean id="datasource" class="DataSourceService" >
  
    <bean id="userservice" class="UserService"> 
       <property name="datasource" ref="datasource"/>
    </bean> 
    
    ...
</beans>

在其他类中要获取用户信息，通过容器:context提供的方式来获取用户实例context.getName(“userservice”)，就会在容器中找id=“userservice”,进而获取该对象的实例。

IOC的思想

对象的创建交给外部容器完成，这个就是控制反转
spring中使用控制反转来实现对象在不同程序中的使用
控制反转解决对象处理的问题，将对象交给容器进行创建

依赖注入(DI)：dendendency injection
对象与对象之间的依赖问题即依赖注入 AOP->DI
Spring使用依赖注入来实现对象之间的依赖关系
在对象创建之后，对象的关系处理就是依赖注入

无论对象的创建，处理对象之间的依赖关系，对象创建的时间还有对象创建的数量，都可以在spring的IOC容器上配置对象的信息就好了

Spring管理对象

spring集成依赖

        <!--spring的核心依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.1.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>4.1.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.1.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>4.1.7.RELEASE</version>
        </dependency>

        <!--log4j-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

spring的配置文件(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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    
 
</beans>   

创建实体类

先创建需要交给容器管理的类

public class User {
    private Integer id;
    private String name;

   
}

随后将user对象交给容器管理

    <!--使用bean标签类管理对象 id:属性标识对象，不可重复  class属性代表要管理的对象的全路径-->
    <bean id="user" class="com.tulun.bean.User"/>

通过容器来获取User对象

        //获取IOC容器,通过读取classpath路径下的spring的配置文件
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationcontext.xml");
        //在IOC容器获取需要的对象实例
        User user = (User) applicationContext.getBean("user");

IOC容器

Spring IOC容器的继承关系，ApplicationContext是BeanFactory子接口实现之一，BeanFactory是IOC容器定义的最底层的接口。

ApplicationContext是高级实现之一，对BeanFactory的接口做了很多的扩展，大部分情况使用ApplicationContext。

ApplicationContext接口常见的实现类
ClassPathXmlApplicationContext

ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationcontext.xml");

用于读取classpath中的资源

FileSystemXmlApplicationContext

FileSystemXmlApplicationContext applicationContext1 = new FileSystemXmlApplicationContext("d://test.xml");

读取系统指定的资源文件

XmlWebApplicationContext

 XmlWebApplicationContext applicationcontext = new XmlWebApplicationContext();

读取web环境下的资源文件

我们可以通过一幅图来了解一下IOC容器获取bean对象的过程

Spring对Bean的实例化方式

基于配置形式

通过无参构造函数实例化

<!--通过无参构造来实例化Bean-->
    <bean id="user" class="com.tulun.bean.User" scope="singleton"/>

spring容器对上面的类的实例化采用的是无参构造函数来实例化bean
注意：如果不指定无参构造函数，会生成一个默认的无参构造函数，如果指定了有参构造函数，（就不会生成默认的无参构造函数），就必须显性的写明一个无参构造函数

通过静态工厂方式实例化

首先创建静态工厂类来获取User对象

public class StaticFactory {
    public static User getUser(){
        return new User();
    }
}

spring容器管理配置如下：

<!--通过静态工厂类获取User对象-->
    <bean id="user1" class="com.tulun.factory.StaticFactory" factory-method="getUser"/>

静态工厂方式获取对象是 class属性工厂类的全路径，factory-method属性指在工厂类中指定的方法来获取需要的对象

通过普通工厂方式来实例化Bean

创建一个普通工厂来管理user

/**
 * 普通工厂
 */
public class CommonFactory {

    public User getUser(){
        return new User();
    }
}

spring 容器的配置如下：

<!--通过普通工厂类获取User对象-->
    <!--先获取工厂实例-->
    <bean id="factory" class="com.tulun.factory.CommonFactory"/>
    <!--指定工厂类的方法-->
    <bean id="user2"  factory-bean="factory" factory-method="getUser"/>

首先需要获取工厂实例，通过普通工厂实例获取user对象时，factory-bean属性指的是容器管理的工厂对象，factory-method属性指的是工厂中获取user对象的方法。

基于注解形式

基于注解形式比xml方式更加简单，开发更快，在前面介绍mybatis时我们也使用过注解

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

    <!--开启扫描注解：指定的包路径下的类，会扫描的到类的方法，属性上-->
    <context:component-scan base-package="com.tulun.bean"/>
    
    <!--只扫描类中属性的注解（不建议使用）-->
    <!--<context:annotation-config></context:annotation-config>-->
    
</beans>    

在对应的类上面去添加相应的注解

@Component("user")
//注解中user=XML配置形式中bean  id属性
public class User {
    private Integer id;
    private String name;
}

这里的注解使用@Compoment,其他注解如下

• @Component:通用注解
• @Repository:对DAO层实现类进行标注
• @Service：对Service层业务逻辑层进行标注
• @Controller：对Controller的实现类进行标注
  其实这四个注解可以通用，功能是一样的，可以互换，我们使用不同注解主要是加入我们要进行web开发时，可以区别不同的业务层，使逻辑更加清晰。

Spring中依赖注入方式

bean的实例化说明的是IOC的问题，创建对象之后对象中的属性如何赋值问题，即依赖注入问题（DI）。这里同样有两种方式，一是通过xml配置方式进行依赖注入，另一种便是注解形式进行依赖注入。

基于xml配置实现依赖注入

通过有参构造函数

这种方式，实体类必须提供有参构造函数。

public class User {
    private Integer id;
    private String name;

    /**
     * 有参构造函数
     */
    public User(Integer id, String name) {
        this.id = id;
        this.name = name;
    }

容器中要进行以下配置

public class User {
    private Integer id;
    private String name;

    /**
     * 有参构造函数
     */
    public User(Integer id, String name) {
        this.id = id;
        this.name = name;
    }

通过有参构造函数完成依赖注入时，使用constructor-arg标签进行属性赋值。

setter方式

这需要类中具有setter方法

public class User {
    private Integer id;
    private String name;

    public User() {
    }
    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

而容器中的配置信息如下：

    <!--依赖注入：setter方式-->
    <bean id="user4" class="com.tulun.bean.User">
        <!--属性注入-->
        <property name="id" value="2"/>
        <property name="name" value="基础班"/>
    </bean>

setter方式的依赖注入：使用property标签进行赋值

也可以对自定义类型进行注入，无论是set还是有参构造都可以。在对它进行赋值时要使用ref

    <bean id="user3" class="com.tulun.bean.User">
        <constructor-arg name="book" ref="book"/>
    </bean>

如果要注入集合类型：数组、set、list、Map等等

以map类型为例

public class User {
    private Integer id;
    private String name;
    private Map<String ,String> map; //map 类型属性

在容器中的配置

 <!--map集合类型-->
    <bean id="user5" class="com.tulun.bean.User">
        <!--属性注入-->
        <property name="id" value="3"/>
        <property name="name" value="基础班1"/>
        <property name="map" >
            <
            <map >
                <entry key="1" value="11"></entry>
                <entry key="2" value="22"></entry>
                <entry key="3" value="33"></entry>
            </map>
        </property>
    </bean>

基于注解形式注入依赖

@Value(“3”)//注入普通类型属性
@Resource //注入对象类型
@Autowired //注入对象类型，默认是按照类型注解

依赖的注入都是在类的属性上

那@Resource 和@Autowired有什么区别呢？

Spring中，@Resource和@Autowired都是做bean的注入时使用。使用过程中，有时候@Resource 和 @Autowired可以替换使用；有时，则不可以。

共同点
@Resource和@Autowired都可以作为注入属性的修饰，在接口仅有单一实现类时，两个注解的修饰效果相同，可以互相替换，不影响使用。

不同点
@Resource是Java自己的注解，@Resource有两个属性是比较重要的，分是name和type；Spring将@Resource注解的name属性解析为bean的名字，而type属性则解析为bean的类型。所以如果使用name属性，则使用byName的自动注入策略，而使用type属性时则使用byType自动注入策略。如果既不指定name也不指定type属性，这时将通过反射机制使用byName自动注入策略。

@Autowired是spring的注解，是spring2.5版本引入的，Autowired只根据type进行注入，不会去匹配name。如果涉及到type无法辨别注入对象时，那需要依赖@Qualifier或@Primary注解一起来修饰