Spring核心内容

一、Spring核心内容IOC容器

1.IOC作用

负责对象的实例化、对象的初始化、对象和对象之间的依赖关系配置、对象的销毁、对象提供对象的查找等操作，对象的整个生命周期都是容器来控制的。使用IOC容器进行管理后，则不需要我们手动通过new的方式去创建对象，由容器帮我们组装好直接用即可。这就是Spring的容器。

2.Spring如何管理对象的

由Spring容器管理的对象统称为Bean对象。我们需要通过在配置文件中告诉Spring容器需要创建哪些Bean对象，所以需要先在配置文件中定义好需要创建的对象，这些配置统称为bean定义配置元素数据信息，Spring容器通过读取这些bean配置元素数据信息来构建和组装我们所需的对象。

BeanFactory接⼝

org.springframework.beans.factory.BeanFactory

spring容器中具有代表性的容器就是BeanFactory接⼝，这个是spring容器的顶层接⼝，提供了容器最基本的功能。

常⽤的⼏个⽅法

//按bean的id或者别名查找容器中的bean

Object getBean(String name) throws BeansException

//这个是⼀个泛型⽅法，按照bean的id或者别名查找指定类型的bean，返回指定类型的bean对象

<T> T getBean(String name, Class<T> requiredType) throws BeansException;

//返回容器中指定类型的bean对象

<T> T getBean(Class<T> requiredType) throws BeansException;

//获取指定类型bean对象的获取器，这个⽅法⽐较特别，以后会专门来讲

<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);

ApplicationContext接⼝

org.springframework.context.ApplicationContext

这个接⼝继承了BeanFactory接⼝，所以内部包含了BeanFactory所有的功能，并且在其上进⾏了扩展，增加了很多企业级功能，⽐如AOP、国际化、事件⽀持等等。

容器中创建对象的方式：

方法一：XML配置Bean

在配置文件中进行编写Bean，这个方法非常常见，举个例子：

<bean id="car" class="com.lm.spring.bean.Car">

这种定义方法相当于Car car = new Car() 然后 注册car到spring容器。用的时候直接用。

方法二：@Bean

这个方法是spring boot流行后的常用方法。本质和XML配置方法相同。所有用XML配置文件的方法都可以用这个方法改写。

@Configuration
public class ConfigUtil {

    @Bean
    public ActionOneyDay getActionOneyDay(){
        return new ActionOneDayImpl();
    }
}

方法三：BeanFacoty registerSingleton

通过配置方式或者注解方式，由Spring容器去创建对象。默认情况下为Singleton模式。

注解类型方式：

@Service—服务层

@Component—组建层

@Repository—数据层

@Contrlloer—用户层

3.Spring注入对象的方式

方式一：Constructor注入

Constructor Injection是构造器注入，是我们日常最为推荐的一种使用方式。

@RestController public class OrderController {     //声明所要注入的对象     private OrderService orderService;
    //基于构造函数的方式注入对象     public OrderController(OrderService orderService) {         this.orderService = orderService;     }     @GetMapping("/order")     public String order() {         return orderService.order();     } }

方法二：Setter注入

Setter Injection也会用到@Autowired注解，但使用方式与Field Injection有所不同，Field Injection是用在成员变量上，而Setter Injection的时候，是用在成员变量的Setter函数上。

@RestController
public class OrderController {

    //声明所要注入的对象
    private OrderService orderService;

    @Autowired
    public void setOrderService(OrderService orderService) {
        this.orderService = orderService;

    }

    @GetMapping("/order")
    public String order() {
        return orderService.order();
    }
}

方式三：Field 注入

@RestController
public class AirportController {

    @Autowired
    private AirportService airportService;
    @RequestMapping("/airport")
    public List<AirPort> getInfo(String airPortNum){
        String aa=null;
        Optional.ofNullable(aa).ifPresent(name->{
            System.out.println("测试数据：111111");
        });
        double[] ds= new double[]{};
        for (double dd:ds){
        }
        return airportService.getInfo(airPortNum);
    }

}

这种注入方式通过Java的反射机制实现，所以private的成员也可以被注入具体的对象。这种方式在日常开发中比较常用。

二、Spring核心内容AOP

AOP：面向切面编程。

面向切面编程（Aspect Orient Programming）支持允许将一些通用的任务如缓存、日志记录、性能统计、安全控制、事务处理、异常处理等进行集中式处理，从而提供了更好的复用，AOP通常用来处理一些具有横切性质的系统级服务。

利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

1.切面

@Aspect:定义一个切面，对应的一个实现AOP的类定义

2.切点

@Pointcut：定义一个切点

@Pointcut("execution(* com.ydb.service..*.*(..))")

@Pointcut("@annotation(org.springframework.web.bind.annotation.GetMapping)")

比如：

@Pointcut("execution(* com.ydb.service..*.*(..))")
private void aopCheck() { }

@Around("aopCheck()")
public Object aroundAspect(ProceedingJoinPoint joinPoint) throws Throwable {
    System.out.println("Aspect--环绕通知方法开始执行！！！");
    Object o = joinPoint.proceed();
    System.out.println("Aspect--环绕通知方法开结束执行！！");
    return o;
}

3.通知

• 前置通知（Before）:在目标方法或者说连接点被调用前执行的通知；
• 后置通知（After）：指在某个连接点完成后执行的通知；
• 返回通知（After-returning）：指在某个连接点成功执行之后执行的通知；
• 异常通知（After-throwing）：指在方法抛出异常后执行的通知；
• 环绕通知（Around）：指包围一个连接点通知，在被通知的方法调用之前和之后执行自定义的方法。

比如：

@Pointcut("@annotation(org.springframework.web.bind.annotation.GetMapping)")
private void annotation(){}

@Before("annotation()")
public void aspectMethodBefore(){
    System.out.println("Aspect---方法执行前！！！");
}

@After("annotation()")
public void aspectMethodAfter(){
    System.out.println("Aspect---方法执行后！！！");
}

@Around("aopCheck()")
public Object aroundAspect(ProceedingJoinPoint joinPoint) throws Throwable {
    System.out.println("Aspect--环绕通知方法开始执行！！！");
    Object o = joinPoint.proceed();
    System.out.println("Aspect--环绕通知方法开结束执行！！");
    return o;
}