Spring IoC 和AOP

我要学到凌晨三点半

已于 2022-06-19 01:15:24 修改

阅读量700

点赞数

文章标签： spring java mvc

于 2022-06-19 01:13:29 首次发布

本文链接：https://blog.csdn.net/qq_37746859/article/details/125350380

版权

具体代码详情

http://F:\WorkSpace\springIoc

Bean是一个注解pojo指对象是一个概念性的东西，他俩其实都是描述对象的

把不影响业务的非业务代码抽离出来：AOP

如果是函数，需要在业务代码中调用。AOP不需要在业务代码中调用，直接在切面类中配置就可以

代码的扩展性和维护下提高

切面类只能和一个实现类生成代理，不能同时对两个实现类生成代理

Spring 框架 Java 开发的行业标准
Spring 全家桶
Web：Spring Web MVC/Spring MVC、Spring Web Flux
持久层：Spring Data/ Spring Data JPA、Spring Data
Redis、Spring Data MongoDB
安全校验：Spring Security
构建工程脚手架：Spring Boot
微服务：Spring Cloud
IoC 是 Spring 全家桶各个功能模块的基础，创建对象的容器。
AOP 也是以 IoC 为基础，AOP 是面向切面编程，抽象化的面向对象
1、打印日志
2、事务
3、权限处理
1.1 IoC
控制反转，将对象的创建进行反转，常规情况下，对象都是开发者手动创建的，使用 IoC 开发者不再需要创建对象，而是由 IoC 容器根据需求自动创建项目所需要的对象。
不用 IoC：所有对象开发者自己创建
使用 IoC：对象不用开发者创建，而是交给 Spring 框架来完成

1、pom.xml

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.15</version>
</dependency>

基于 XML 和基于注解
基于 XML：开发者把需要的对象在 XML 中进行配置，Spring 框架读取这个配置文件，根据配置文件的内容来创建对象

<?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:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
       
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
       
http://www.springframework.org/schema/context
       
http://www.springframework.org/schema/context/spring-context.xsd
       
http://www.springframework.org/schema/aop
       
http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
    <bean class="com.southwind.ioc.DataConfig" 
id="config">
        <property name="driverName" 
value="Driver"></property>
        <property name="url" 
value="localhost:8080"></property>
        <property name="username" value="root">
</property>
        <property name="password" value="root">
</property>
</bean>
</beans>

package com.southwind.ioc;
import 
org.springframework.context.ApplicationContext;
import 
org.springframework.context.support.ClassPathXm
lApplicationContext;
public class Test {
    public static void main(String[] args) {
//        DataConfig dataConfig = new 
DataConfig();
//        dataConfig.setDriverName("Driver");
//        
dataConfig.setUrl("localhost:3306/dbname");
//        dataConfig.setUsername("root");
//        dataConfig.setPassword("root");
        ApplicationContext context = new 
ClassPathXmlApplicationContext("spring.xml");
       
 System.out.println(context.getBean("config"));
    }
}

基于注解
1、配置类
用一个 Java 类来替代 XML 文件，把在 XML 中配置的内容放到配置类中。

package com.southwind.configuration;
import com.southwind.ioc.DataConfig;
import 
org.springframework.context.annotation.Bean;
import 
org.springframework.context.annotation.Configur
ation;
@Configuration
public class BeanConfiguration {
    @Bean(value = "config")
    public DataConfig dataConfig(){
        DataConfig dataConfig = new 
DataConfig();
        dataConfig.setDriverName("Driver");
       
 dataConfig.setUrl("localhost:3306/dbname");
        dataConfig.setUsername("root");
        dataConfig.setPassword("root");
        return dataConfig;
    }
}

ApplicationContext context = new 
AnnotationConfigApplicationContext(BeanConfigur
ation.class);
System.out.println(context.getBean("config"));

2、扫包+注解

更简单的方式，不再需要依赖于 XML 或者配置类，而是直接将 bean 的创建交给目标类，在目标类添加注解来创建

package com.southwind.ioc;
import lombok.Data;
import 
org.springframework.beans.factory.annotation.Va
lue;
import 
org.springframework.stereotype.Component;
@Data
@Component
public class DataConfig {
    @Value("localhost:3306")
    private String url;
    @Value("Driver")
    private String driverName;
    @Value("root")
    private String username;
    @Value("root")
    private String password;
}

ApplicationContext context = new 
AnnotationConfigApplicationContext("com.southwi
nd.ioc");
System.out.println(context.getBean(DataConfig.c
lass));

自动创建对象，完成依赖注入

package com.southwind.ioc;
import lombok.Data;
import 
org.springframework.beans.factory.annotation.Au
towired;
import 
org.springframework.beans.factory.annotation.Va
lue;
import 
org.springframework.stereotype.Component;
@Data
@Component
public class GlobalConfig {
    @Value("8080")
    private String port;
    @Value("/")
    private String path;
    @Autowired
    private DataConfig dataConfig;
}

@Autowired 通过类型进行注入，如果需要通过名称取值，
通过 @Qualifier 注解完成名称的映射

package com.southwind.ioc;
import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Data
@Component
public class GlobalConfig {
    @Value("8080")
    private String port;
    @Value("/")
    private String path;
    @Autowired
    @Qualifier("config")
    private DataConfig config;
}

package com.southwind.ioc;
import lombok.Data;
import 
org.springframework.beans.factory.annotation.Va
lue;
import 
org.springframework.stereotype.Component;
@Data
@Component("config")
public class DataConfig {
@Value("localhost:3306")
    private String url;
    @Value("Driver")
    private String driverName;
    @Value("root")
    private String username;
    @Value("root")
    private String password;
}

1.2 AOP
面向切面编程，是一种抽象化的面向对象编程，对面向对象
编程的一种补充，底层使用动态代理机制来实现
1、打印日志
2、事务
3、权限处理
打印日志
业务代码和打印日志耦合起来

计算器方法中，日志和业务混合在一起，AOP 要做的就是将日志代码全部抽象出去统一进行处理，计算器方法中只保留核心的业务代码。
做到核心业务和非业务代码的解耦合

1、创建切面类

package com.southwind.aop;
import org.aspectj.lang.JoinPoint;
import 
org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
import java.util.Arrays;
@Component
@Aspect
public class LoggerAspect {
    @Before("execution(public int com.southwind.aop.CalImpl.*(..))")
    public void before(JoinPoint joinPoint){
String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法的参数是"+ Arrays.toString(joinPoint.getArgs()));
    }
    @AfterReturning(value = "execution(public int com.southwind.aop.CalImpl(..))",returning 
= "result")
    public void afterReturning(JoinPoint joinPoint,Object result){
        String name = joinPoint.getSignature().getName();
        System.out.println(name+"方法的结果是"+result);
    }
}

2、实现类添加 @Component 注解

package com.southwind.aop;
import 
org.springframework.stereotype.Component;
@Component
public class CalImpl implements Cal {
    @Override
    public int add(int num1, int num2) {
        int result = num1 + num2;
        return result;
    }
@Override
    public int sub(int num1, int num2) {
        int result = num1 - num2;
        return result;
    }
    @Override
    public int mul(int num1, int num2) {
        int result = num1 * num2;
        return result;
    }
    @Override
    public int div(int num1, int num2) {
        int result = num1 / num2;
        return result;
    }
}

3、配置自动扫包，开启自动生成代理对象

<?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:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
       
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
       
http://www.springframework.org/schema/context
       
http://www.springframework.org/schema/context/spring-context.xsd
       
http://www.springframework.org/schema/aop
       
http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
    <!-- 自动扫包 -->
    <context:component-scan base-package="com.southwind.aop">
</context:component-scan>
    <!-- 开启自动生成代理 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

4、使用

package com.southwind.aop;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
    public static void main(String[] args) {
        ApplicationContext context = new 
ClassPathXmlApplicationContext("spring.xml");
        Cal bean = context.getBean(Cal.class);
        System.out.println(bean.add(9, 8));
        System.out.println(bean.sub(9, 8));
        System.out.println(bean.mul(9, 8));
        System.out.println(bean.div(9, 8));
    }
}

Spring 官方文档对 bean 的解释是：
In Spring, the objects that form the backbone of your application and that are managed by the Spring IoC container are called beans. A bean is an object that is instantiated, assembled, and otherwise managed by a Spring IoC container.

翻译过来就是：
在 Spring 中，构成应用程序主干并由Spring IoC容器管理的对象称为bean。bean是一个由Spring IoC容器实例化、组装和管理的对象。

我们总结如下：
1.bean是对象，一个或者多个不限定
2.bean由Spring中一个叫IoC的东西管理
3.我们的应用程序由一个个bean构成

2 控制反转（IoC）
控制反转英文全称：Inversion of Control，简称就是IoC。

控制反转通过依赖注入（DI）方式实现对象之间的松耦合关系。

程序运行时，依赖对象由【辅助程序】动态生成并注入到被依赖对象中，动态绑定两者的使用关系。

Spring IoC容器就是这样的辅助程序，它负责对象的生成和依赖的注入，让后在交由我们使用。

简而言之，就是：IoC就是一个对象定义其依赖关系而不创建它们的过程。

这里我们可以细分为两个点。

2.1 私有属性保存依赖
第1点：使用私有属性保存依赖对象，并且只能通过构造函数参数传入，

构造函数的参数可以是工厂方法、保存类对象的属性、或者是工厂方法返回值。

假设我们有一个Computer类：

我们有另一个Person类依赖于Computer类，符合IoC的做法是这样：

不符合IoC的做法如下：

2.2 让Spring控制类构建过程
第2点：不用new，让Spring控制new过程。

在Spring中，我们基本不需要 new 一个类，这些都是让 Spring 去做的。

Spring 启动时会把所需的类实例化成对象，如果需要依赖，则先实例化依赖，然后实例化当前类。

因为依赖必须通过构建函数传入，所以实例化时，当前类就会接收并保存所有依赖的对象。

这一步也就是所谓的依赖注入。

2.3 这就是IoC
在 Spring 中，类的实例化、依赖的实例化、依赖的传入都交由 Spring Bean 容器控制，

而不是用new方式实例化对象、通过非构造函数方法传入依赖等常规方式。

实质的控制权已经交由程序管理，而不是程序员管理，所以叫做控制反转。

3 Bean？
至于bean，则是几个概念。

概念1：Bean容器，或称spring ioc容器，主要用来管理对象和依赖，以及依赖的注入。
概念2：bean是一个Java对象，根据bean规范编写出来的类，并由bean容器生成的对象就是一个bean。

bean规范如下：

1.所有属性为private
2.提供默认构造方法
3.提供getter和setter
4.实现serializable接口

1.什么是AOP
AOP的全称是Aspect-Oriented Programming，即面向切面编程（也称面向方面编程）。它是面向对象编程（OOP）的一种补充，目前已成为一种比较成熟的编程方式。
在传统的业务处理代码中，通常都会进行事务处理、日志记录等操作。虽然使用OOP可以通过组合或者继承的方式来达到代码的重用，但如果要实现某个功能（如日志记录），同样的代码仍然会分散到各个方法中。这样，如果想要关闭某个功能，或者对其进行修改，就必须要修改所有的相关方法。这不但增加了开发人员的工作量，而且提高了代码的出错率。
为了解决这一问题，AOP思想随之产生。AOP采取横向抽取机制，将分散在各个方法中的重复代码提取出来，然后在程序编译或运行时，再将这些提取出来的代码应用到需要执行的地方。这种采用横向抽取机制的方式，采用传统的OOP思想显然是无法办到的，因为OOP只能实现父子关系的纵向的重用。虽然AOP是一种新的编程思想，但却不是OOP的替代品，它只是OOP的延伸和补充。

AOP的使用，使开发人员在编写业务逻辑时可以专心于核心业务，而不用过多的关注于其他业务逻辑的实现，这不但提高了开发效率，而且增强了代码的可维护性。

1、Advice（通知/增强处理）：AOP框架在特定的切入点执行的增强处理，即在定义好的切入点处所要执行的程序代码。可以将其理解为切面类中的方法。
2、Target Object（目标对象）：指所有被通知的对象，也被称为被增强对象。如果AOP框架采用的是动态的AOP实现，那么该对象就是一个被代理对象。
3、Proxy（代理）：将通知应用到目标对象之后，被动态创建的对象。
4、Weaving（织入）：将切面代码插入到目标对象上，从而生成代理对象的过程。

JDK动态代理是通过java.lang.reflect.Proxy 类来实现的，我们可以调用Proxy类的newProxyInstance()方法来创建代理对象。对于使用业务接口的类，Spring默认会使用JDK动态代理来实现AOP。