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 getBean(String name, Class requiredType) throws BeansException;

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

T getBean(Class requiredType) throws BeansException;

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

ObjectProvider getBeanProvider(Class requiredType);

ApplicationContext

org.springframework.context.ApplicationContext

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

容器中创建对象的方式:

方法一:XML配置Bean

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

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

你可能感兴趣的:(spring,java,后端)