1.从宏观上看spring框架和springboot

Spring框架解决了企业级的开发的复杂性，它是一个容器框架，用于装java对象（Bean），使程序间的依赖关系交由容器统一管理，松耦合，提高了可测试性和维护效率，Spring主要为我们做了两件事，一省去了我们创建对象的操作，二声明了属性赋值。总体而言，Spring框架就是为我们解决开发中的基础性问题，使我们开发者可以更加专注于应用程序的开发，并且Spring框架是轻量级框架，扩展性强，非侵入式框架，消耗的资源少，占用的空间小，运行和部署简单。

Spring Boot是一个微服务框架，延续了Spring框架的核心思想IOC和AOP，简化了应用的开发和部署。

Spring Boot框架是对Spring框架的补充，它消除了Spring框架配置XML的麻烦事，完善了Spring框架的开发环境，使我们可以更加高效的完成编程，并且为我们提供了 spring-boot-starter-web 依赖，这个依赖包含了Tomcat和springmvc等一系列的web依赖（无需部署war文件）。以前的时候SpringMVC要配置properties文件的时候需要写大量的配置，现在用Spring Boot只需要导入相关依赖，然后写两句话就可以配置完Web程序，并且还提供了@Configuration来替代XML配置。 

2.配置maven

如果面对一项工程，可以将maven想象成外包的工程队，将楼体的基础建设完成后再交给springboot，由springboot自己完成内部的装修。

配置maven文件的过程 ：

将maven文件下载到电脑中 

在idea（或ecilipse）中配置好maven：

将相关文件下载（idea中maven栏在右侧，在maven栏上侧第三个是下载）： 

注意下载时间可能很慢

 3.搭建springboot项目

编写依赖：

在网站https://mvnrepository.com/中，搜索启动依赖，复制依赖到pom.xml文件下

注意一定要写在<dependencies></dependencies>中

创建项目启动类

写好依赖后就可以创建项目启动类：

package com.easy;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;


@SpringBootApplication
public class EasySpringAApplication {
    //项目启动类  运行起该类就运行了整个项目
    public static void main(String[] args) {
        SpringApplication.run(EasySpringAApplication.class,args);
    }
}

 4.一个实例

@RestController
public class EasyController {
    @RequestMapping("hello")
    public String hello(){
        return "Go Clippers";
    }
}

在网页中网址栏输入：localhost:8080/hello 就可以跳转到我们编写的一个简易网页

5.IOC   控制反转

IOC：控制反转

Spring IOC 作用：管里项目中java bean的生命周期

在项目运行阶段，程序中需要很多的对象来完成整体的业务 ，Springboot提供了很多注解了来标注类，让spring管理这些类的对象的生命周期 ，Spring提供了IOC的方式方便获取该对象 。

IOC==控制反转（即控制权反转） 容器和代码之间的控制权反转，代码中不需要明文获取(调用)方法，来得到对象，只需要声明该类需要什么类型的对象即可。

6.DI  依赖注入

DI：依赖注入

通过识别依赖关系注入对应的对象

7.常用注解

@Controller

@RestController(访问层)

@Service(业务类)

@Repository(Dao数据访问)

@Component(其他功能类)

@Bean

@Configuration

注意：Service注解是不能代替Controller注解的

8.spring bean的作用域

Spring Bean的作用域：

1.SingleTon  单例模式  一个对象     是默认的作用域！！！

2.ProtoType  原型模式  每次需要都来一个新的对象

3.Request web  请求作用域  每次请求都会创建一个新的对象，但是对象可以被很多类指向 @Scope( value = "request")

4.Session  每次会话都会创建一个新的对象

5.GlobalSession 全局的

9.spring bean的生命周期

public class EasyBean implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean, DisposableBean {
    public EasyBean(){
        System.out.println("1--构造方法");
    }

    public void init(){
        System.out.println("8--init method");
    }

    TestA testa;

    @Autowired
    public void setTesta(TestA testa){
        System.out.println("2--注入属性");
        this.testa=testa;
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("3--BeanNameAware接口的setBeanName方法"+name);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("4--BeanFactoryAware接口的setBeanFactory方法"+beanFactory);
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("5--ApplicationContextAware接口的setApplicationContext方法"+applicationContext);
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("7--InitializingBean接口的afterPropertiesSet");
    }


    @Override
    public void destroy() throws Exception {
        System.out.println("easyBean被回收了");
    }

public class EasyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.equals("easyBean")){
            System.out.println("6--"+beanName+"--BeanPostProcessor的Before");
        }
        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.equals("easyBean")){
            System.out.println("9--BeanPostProcessor的After");
        }
        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}

1）根据配置情况调用 Bean 构造方法或工厂方法实例化 Bean。

2）利用依赖注入完成 Bean 中所有属性值的配置注入。

3) 如果 Bean 实现了 BeanNameAware 接口，则 Spring 调用 Bean 的 setBeanName() 方法传入当前 Bean 的 id 值。

4）如果 Bean 实现了 BeanFactoryAware 接口，则 Spring 调用 setBeanFactory() 方法传入当前工厂实例的引用。

5) 当一个 Bean 实现了 ApplicationContextAware 接口并在 Spring 容器中被实例化时，Spring 容器会自动调用该 Bean 的 setApplicationContext 方法，并将应用程序上下文ApplicationContext作为参数传递进来

6）BeanPostProcessor 是 Spring 框架中的一个重要接口，它允许开发者在 Spring 容器创建和初始化 bean 的过程中，对 bean 进行自定义处理。这包括在 bean 实例化之后、属性设置之前（postProcessBeforeInitialization 方法），以及在 bean 初始化之后（postProcessAfterInitialization 方法）执行自定义逻辑。Spring 容器在创建和初始化每一个 bean 时，都会调用 CustomBeanPostProcessor 中的这两个方法，允许你进行自定义处理

7）InitializingBean 是 Spring 框架中的一个接口，它定义了一个 afterPropertiesSet 方法。当 Spring 容器创建 bean 的所有属性都被设置完成后，会调用这个方法。

8）如果在配置文件中通过 init-method 属性指定了初始化方法，则调用该初始化方法。

9）如果 BeanPostProcessor 和 Bean 关联，则 Spring 将调用该接口的初始化方法 postProcessAfterInitialization()。此时，Bean 已经可以被应用系统使用了。

10）如果在 <bean> 中指定了该 Bean 的作用范围为 scope="singleton"，则将该 Bean 放入 Spring IoC 的缓存池中，将触发 Spring 对该 Bean 的生命周期管理；如果在 <bean> 中指定了该 Bean 的作用范围为 scope="prototype"，则将该 Bean 交给调用者，调用者管理该 Bean 的生命周期，Spring 不再管理该 Bean。

11）如果 Bean 实现了 DisposableBean 接口，则 Spring 会调用 destory() 方法将 Spring 中的 Bean 销毁；如果在配置文件中通过 destory-method 属性指定了 Bean 的销毁方法，则 Spring 将调用该方法对 Bean 进行销毁。