【spring专题】spring简介_Java

前景概要

　　对于现在的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 的不同，其主要区别有：