【spring专题】spring简介

前景概要

　　对于现在的Java开发基本上可以说成是spring开发，spring全家桶可以说是把整个Java web安排的明明白白的。正因为使用的很多，所以作为一名开发者不应该仅仅是会使用spring，更要对spring的知识有一定深度的了解。这样不论是工作还是面试都是有所帮助的。spring的实现使用了大量的设计模式，单纯的看设计模式比较难以理解，结合spring代码来看效率应该会更高一些，这也是我想看spring的原因。spring的核心是ioc与aop，所以通过这次的学习希望对ioc与aop有更深层次的理解。最后说明一下这个专题的文章是我自己的学习笔记，由于我个人水平有限，所以如果有大佬偶然看到还希望能给予指正。

什么是spring

　　spring是一款简便开发的轻量级框架（细节的概念我就不cv了）。

为什么要使用spring

　　是因为别人都在用吗？为啥别人都用呢，简化开发你用不用？当然的用，现在的Javaweb开发基本上可以说就是spring开发了，spring开发不用spring用啥？

　　正经点说就是，除了spring我也没用过别的，不然我写这个专题干嘛，就别为难我胖虎了。

怎么使用spring

　　1. 导jar包

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>

　　2.需要一个被代理的类

package com.jeff_code;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

public class Person implements BeanNameAware, ApplicationContextAware, InitializingBean, DisposableBean {
    private String name;

    public Person() {
        System.out.println("1.构造器创建类");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("2.set参数");
        this.name = name;
    }

    public void init() {
        System.out.println("7. 初始化方法");
    }

    public void destory() {
        System.out.println("11.全部结束整个销毁方法");
    }

    @Override
    public void setBeanName(String s) {
        System.out.println("3.将xml配置中的id/name的名字得到");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("4.让我们的类了解工厂信息了");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("6. 属性设置后执行");
    }

    public void sayHello() {
        System.out.println("9. 如果调用了它的方法才会执行到这个生命周期,"+ name);
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("10. Spring的一个销毁方法");
    }
}

　　3.需要一个配置文件进行bean的注入

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

    <bean id="person" class="com.jeff_code.Person" init-method="init" destroy-method="destory">
        <property name="name" value="jeff"></property>
    </bean>
    <!--前后置处理器是生命周期的一个步骤，不需要我们配id调用的-->
    <bean class="com.jeff_code.MyBeanPostProcessor">

    </bean>
</beans>

　　4. 我们就可以使用spring生成一个object了

package com.jeff_code;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

    @org.junit.Test
    public void testLife() {
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml");
        Person person = ac.getBean("person", Person.class);
        person.sayHello();
        ac.close();
    }
}

　　我们就使用spring生成了一个我们要使用对象，关于对象是怎么init，destroy，怎么注入，何时属性赋值等操作，使用者是感知不到的。当然你要觉得写这么多还不如new Person()来的快，我觉得你说得对，就这个demo来说是这样的，我不反驳，如果你做过大一点的web项目，我觉得应该不会这么说。关于这个特点也是ioc带来的便利，我这里只是简单的概要，只讲一下实现的思路。

　　使用spring是不难看出，我们使用了一个ApplicationContext，读取了我们的配置文件，这时你可能想这是spring提供的类，这个类的功能就是读取xml文件，解析出配置中需要注入的bean，然后通过反射机制生成一个对象，将对象存在ioc容器中，所以在第二步getBean方法直接就获取到这个对象，此时我们就可以使用这个对象了。粗略的说，我认为粗略地说（很粗）控制反转确实就是这样实现的。

什么是ioc

　　IoC全称为Inversion of Control，翻译为 “控制反转”，他和依赖注入（DI，Dependency Injection）指的是一回事。专业名词不好懂是不是，那就说的简单一点，ioc就是取代了new Object()的方式，由 Spring IOC 容器来负责对象的生命周期和对象之间的关系。

为什么使用ioc

　　最早接触面向对象就知道，创建一个对象的方法最简单常用的就是new Object().，这种方式首先就是不够优雅，其次众所周知，程序员都是懒得一笔的，我每次使用对象都要new这也太麻烦了吧，我直接就能用不是更好吗，当然最重要的ioc控制反转，将创建对象的正向操作变成一种由ioc容器反向提供的方式，但是你很难想象ioc还包含着依赖关系的。因为控制反转这个名字实在是联系不上两个对象的依赖关系，所以那位微服务架构大佬，马丁福乐给ioc起了个更为形象的名字“依赖注入”。

　　

　　后面主要写一下完成spring的五种类的源码实现，一下是简介：

　　①Resource，对资源的抽象，它的每一个实现类都代表了一种资源的访问策略，如ClasspathResource 、 URLResource ，FileSystemResource 等， 再用ResourceLoader 来进行统一资源加载。

　　②BeanFactory是一个非常纯粹的bean容器，它是IOC必备的数据结构，其中BeanDefinition是她的基本结构，它内部维护着一个BeanDefinition map，并可根据BeanDefinition的描述进行 bean 的创建和管理。

　　③BeanDefinition 用来描述 Spring 中的 Bean 对象。

　　④BeanDefinitionReader的作用是读取 Spring 的配置文件的内容，并将其转换成 Ioc 容器内部的数据结构：BeanDefinition。

　　⑤ApplicationContext就是Spring容器，它叫做应用上下文，与我们应用息息相关，她继承 BeanFactory，所以它是 BeanFactory 的扩展升级版，如果BeanFactory 是屌丝的话，那么 ApplicationContext 则是名副其实的高富帅。由于ApplicationContext的结构就决定了它与 BeanFactory 的不同，其主要区别有：

1. 继承 MessageSource，提供国际化的标准访问策略。
2. 继承 ApplicationEventPublisher ，提供强大的事件机制。
3. 扩展 ResourceLoader，可以用来加载多个 Resource，可以灵活访问不同的资源。
4. 对 Web 应用的支持。

参考文档：

https://www.martinfowler.com/articles/injection.html

http://cmsblogs.com/?p=2652