JAVA Spring学习Day1

Maven

Maven配置：

Maven是Java项目的构建工具，使用pom.xml配置文件管理项目依赖、插件和构建目标。
Spring Boot项目搭建：

Spring Boot是基于Spring框架的快速开发框架，通过约定大于配置的理念简化了Spring应用的搭建和开发。

Spring

项目启动：

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);
    }
}

Spring核心概念
IOC控制反转：

控制反转是Spring的核心，它通过依赖注入（DI）实现，将对象的创建和管理交由Spring容器负责，降低了组件之间的耦合度。Spring提供了IOC的方式，方便获取该对象。容器和代码之间的控制权反转，代码中不需要明文调用方法来得到对象，只需要声明该类需要什么类型的对象即可。

package com.easy.service;

import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.RequestMapping;

@Service
public class EasyService {
    //Spring IOC
    //管理项目中java bean的生命周期

    //在项目运行阶段，程序中需要很多的对象来完成整体的业务

    //springboot提供了很多注解标注类，
    //@Controller @RestController(访问层) @Repository(Dao数据访问) @Component(其他功能类) @Bean @Service(业务类)
    //让spring管理这些类的对象的生命周期
    //Spring提供了IOC的方式，方便获取该对象
    //IOC==控制反转
    //容器和代码之间的控制权反转，代码中不需要明文调用方法来得到对象，只需要声明该类需要什么类型的对象即可

    //@Service注解是不能代替@Controller
    @RequestMapping("easyaa")
    public String easyaa(){
        return "this is aa";
    }//访问不到404

}

DI依赖注入：

依赖注入是IOC的具体实现方式，通过注入对象所需的依赖关系，实现了组件之间的解耦和灵活性。

package com.easy.controller;

import com.easy.common.TestA;
import com.easy.service.EasyService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class EasyController {
    //该类中需要EasyService类的对象
    //在这个类中只需要声明我们依赖EasyService这个类就可以，不需要代码主动获取EasyService类的对象
    //依赖注入（DI），通过识别依赖关系，注入对应的对象
    @Autowired
    EasyService easyS;
    @Autowired
    TestA testa;
    @RequestMapping("testb")
    public String testB(){
        testa.test();
        return "easy method";
    }
    @RequestMapping("easya")
    public String easya(){
        System.out.println(easyS);
        return "new Service";
    }

    @RequestMapping("hello")
    public String hello(){
        return "java so easy";
    }
}

注解

常用注解：

@Controller：

用于标识控制层组件，处理HTTP请求，返回响应结果。
@RestController：

结合了@Controller和@ResponseBody，用于RESTful风格的控制器，返回JSON数据。
@Service：

标识业务逻辑层组件，通常用于注解业务类。
@Repository：

标识数据访问层组件，通常用于注解DAO类。
@Component：

泛指Spring容器管理的组件，可以用于任何Spring管理的Bean。
@Bean：

用于定义Spring Bean，通常用于配置类中，将方法返回的对象注册为Spring容器的Bean。
@Configuration：

用于定义配置类，替代XML配置文件，其中包含@Bean注解的方法用于定义Bean。

SpringBean

SpringBean作用域：

Singleton：单例模式，一个Spring容器只存在一个实例。
Prototype：每次请求（或注入）时创建一个新实例。
Request：每个HTTP请求创建一个实例（仅在Web环境中有效）。
Session：每次会话都会创建一个新的对象。
GlobalSession：每个全局HTTP Session创建一个实例。

SpringBean的生命周期：

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

    public EasyBean(){
        System.out.println("1------构造方法");
    }

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

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

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

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

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

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

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

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

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

Spring 容器在创建和初始化每一个 bean 时，都会调用 CustomBeanPostProcessor 中的这两个方法，允许你进行自定义处理。（初始化的处理器，before之前是实例化和after之前是初始化）

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

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

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

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

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

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

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

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

运行结果：

了解springbean生命周期的必要性
pring Bean的生命周期定义了从bean的创建、初始化到销毁的一系列过程，以及在这些过程中Spring容器如何与bean进行交互
自定义初始化逻辑：
通过了解Spring Bean的生命周期，你可以知道何时是执行自定义初始化逻辑的最佳时机。例如，你可能需要在bean的依赖项注入之后立即进行某些设置或启动某些服务。通过使用@PostConstruct注解或者init-method属性，你可以确保这些初始化逻辑在bean的依赖项注入之后执行。
自定义销毁逻辑：
同样地，当bean不再需要时，你可能需要执行一些清理操作，如关闭资源连接、释放内存等。通过了解Spring Bean的生命周期，你可以知道何时是执行这些销毁逻辑的最佳时机。你可以通过实现DisposableBean接口或使用@PreDestroy注解来定义自定义的销毁方法。
集成第三方库：
当与第三方库集成时，这些库可能需要在特定的生命周期阶段执行特定的操作。了解Spring Bean的生命周期可以帮助你确定在何处集成这些库，以确保它们能够正常工作。
性能优化：
通过了解Spring Bean的生命周期，你可以更好地优化你的应用程序的性能。例如，如果你知道某个bean只在特定的请求期间需要，你可以考虑将其声明为作用域为request的bean，这样Spring就不会在整个应用程序的生命周期内都持有它的实例。
调试和排错：
当应用程序出现问题时，了解Spring Bean的生命周期可以帮助你更快地定位问题。例如，如果你知道某个bean的初始化方法总是被调用，但某些属性没有被正确设置，那么你可以检查这个初始化方法是否有问题，或者检查是否有其他bean在初始化方法之后修改了这些属性。
更好的设计决策：
了解Spring Bean的生命周期可以帮助你做出更好的设计决策。例如，你可能需要考虑是否将某个功能拆分为多个bean，以及这些bean应该如何相互协作。通过了解生命周期，你可以确定哪些bean应该在其他bean之前或之后创建和销毁。