• 什么是IOC和什么是AOP

    什么是IOC

    控制反转，将对象的创建进行反转，常规情况下，对象都是开发者手动创建的，使用IOC开发者不再需要创建对象，而是由IOC容器根据需求自动创建项目所需要的对象。

    相关依赖：

    1. <dependency>
    2.     <groupId>org.springframeworkgroupId>
    3.     <artifactId>spring-contextartifactId>
    4.     <version>5.3.15version>
    5. dependency>

    案例：

    随便创建一个实体类：

    1. package org.example.pojo;
    2.  
    3. import lombok.Data;
    4. import lombok.experimental.Accessors;
    5.  
    6. @Data
    7. @Accessors(chain = true)
    8. public class DataConfig {
    9.  
    10.     private String ip;
    11.  
    12.     private String dataBaseName;
    13.  
    14.     private String userName;
    15.  
    16.     private String pwd;
    17. }

    不用IOC，所有对象开发者自己创建：

    测试：

    1. package org.example.test;
    2.  
    3. import org.example.pojo.DataConfig;
    4.  
    5. public class Test {
    6.     public static void main(String[] args) {
    7.         DataConfig dataConfig = new DataConfig();
    8.         dataConfig.setIp("127.0.0.1")
    9.                 .setDataBaseName("test")
    10.                 .setUserName("root")
    11.                 .setPwd("ok");
    12.         System.out.println(dataConfig);
    13.     }
    14. }

    测试结果：

    使用IOC，对象不用开发者创建，而是交给Spring框架来完成：

    一、基于XML：

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

    创建一个spring.xml：

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xmlns:context="http://www.springframework.org/schema/context"
    5.        xmlns:p="http://www.springframework.org/schema/p"
    6.        xmlns:aop="http://www.springframework.org/schema/aop"
    7.        xsi:schemaLocation="http://www.springframework.org/schema/beans
    8.        https://www.springframework.org/schema/beans/spring-beans.xsd
    9.        http://www.springframework.org/schema/context
    10.        https://www.springframework.org/schema/context/spring-context.xsd
    11.        http://www.springframework.org/schema/aop
    12.        https://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
    13.     <bean class="org.example.pojo.DataConfig" id="config">
    14.         <property name="ip" value="127.0.0.1" />
    15.         <property name="dataBaseName" value="test" />
    16.         <property name="userName" value="root" />
    17.         <property name="pwd" value="ok" />
    18.     bean>
    19. beans>

    测试：

    1. package org.example.test;
    2.  
    3. import org.springframework.context.ApplicationContext;
    4. import org.springframework.context.support.ClassPathXmlApplicationContext;
    5.  
    6. public class Test2 {
    7.     public static void main(String[] args) {
    8.         ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
    9.         System.out.println(context.getBean("config"));
    10.     }
    11. }

    测试结果：

    二、基于注解：

    1、配置类

    用一个Java类来替代XML文件，把在XML中配置的内容放到配置类中。

    1. package org.example.configuration;
    2.  
    3. import org.example.pojo.DataConfig;
    4. import org.springframework.context.annotation.Bean;
    5. import org.springframework.context.annotation.Configuration;
    6.  
    7. @Configuration
    8. public class BeanConfiguration {
    9.     
    10.     @Bean(value = "config")
    11.     public DataConfig dataConfig(){
    12.         DataConfig dataConfig = new DataConfig();
    13.         dataConfig.setIp("127.0.0.1")
    14.                 .setDataBaseName("test")
    15.                 .setUserName("root")
    16.                 .setPwd("ok");
    17.         return dataConfig;
    18.     }
    19. }

    测试：

    1. package org.example.test;
    2.  
    3. import org.example.configuration.BeanConfiguration;
    4. import org.springframework.context.ApplicationContext;
    5. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    6.  
    7. public class Test3 {
    8.     public static void main(String[] args) {
    9.         ApplicationContext context = new AnnotationConfigApplicationContext(BeanConfiguration.class);
    10.         System.out.println(context.getBean("config"));
    11.     }
    12. }

     测试结果：

    2、扫包+注解

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

    1. package org.example.pojo;
    2.  
    3. import lombok.Data;
    4. import lombok.experimental.Accessors;
    5. import org.springframework.beans.factory.annotation.Value;
    6. import org.springframework.stereotype.Component;
    7.  
    8. @Data
    9. @Component
    10. @Accessors(chain = true)
    11. public class DataConfig2 {
    12.  
    13.     @Value("127.0.0.1")
    14.     private String ip;
    15.  
    16.     @Value("test")
    17.     private String dataBaseName;
    18.  
    19.     @Value("root")
    20.     private String userName;
    21.  
    22.     @Value("ok")
    23.     private String pwd;
    24. }

    测试：

    1. package org.example.test;
    2.  
    3. import org.example.pojo.DataConfig2;
    4. import org.springframework.context.ApplicationContext;
    5. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    6.  
    7. public class Test4 {
    8.     public static void main(String[] args) {
    9.         ApplicationContext context = new AnnotationConfigApplicationContext("org.example.pojo");
    10.         System.out.println(context.getBean(DataConfig2.class));
    11.     }
    12. }

    测试结果：

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

    1. package org.example.pojo;
    2.  
    3. import lombok.Data;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.beans.factory.annotation.Value;
    6. import org.springframework.stereotype.Component;
    7.  
    8. @Data
    9. @Component
    10. public class GlobalConfig {
    11.     @Value("8080")
    12.     private String port;
    13.     @Value("/")
    14.     private String path;
    15.     @Autowired
    16.     private DataConfig2 dataConfig2;
    17. }

    测试：

    1. package org.example.test;
    2.  
    3. import org.example.pojo.GlobalConfig;
    4. import org.springframework.context.ApplicationContext;
    5. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    6.  
    7. public class Test5 {
    8.     public static void main(String[] args) {
    9.         ApplicationContext context = new AnnotationConfigApplicationContext("org.example.pojo");
    10.         System.out.println(context.getBean(GlobalConfig.class));
    11.     }
    12. }

    测试结果：

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

    1. package org.example.pojo;
    2.  
    3. import lombok.Data;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.beans.factory.annotation.Qualifier;
    6. import org.springframework.beans.factory.annotation.Value;
    7. import org.springframework.stereotype.Component;
    8.  
    9. @Data
    10. @Component
    11. public class GlobalConfig2 {
    12.     @Value("8080")
    13.     private String port;
    14.     @Value("/")
    15.     private String path;
    16.     @Autowired
    17.     @Qualifier("config")
    18.     private DataConfig2 dataConfig2;
    19. }

    测试：

    1. package org.example.test;
    2.  
    3. import org.example.pojo.GlobalConfig2;
    4. import org.springframework.context.ApplicationContext;
    5. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    6.  
    7. public class Test6 {
    8.     public static void main(String[] args) {
    9.         ApplicationContext context = new AnnotationConfigApplicationContext("org.example.pojo");
    10.         System.out.println(context.getBean(GlobalConfig2.class));
    11.     }
    12. }

    测试结果：

    什么是AOP

    面向切面编程，是一种抽象化的面向对象编程，对面向对象编程的一种补充，底层使用动态代理机制来实现。

    相关依赖：

    2.     org.springframework
    3.     spring-aspects
    4.     5.3.18

    应用场景：

    打印日志、事务、权限处理

    案例：

    1、创建切面类

    1. package org.example.aop;
    2.  
    3. import org.aspectj.lang.JoinPoint;
    4. import org.aspectj.lang.annotation.AfterReturning;
    5. import org.aspectj.lang.annotation.Aspect;
    6. import org.aspectj.lang.annotation.Before;
    7. import org.springframework.stereotype.Component;
    8.  
    9. import java.util.Arrays;
    10.  
    11. @Component
    12. @Aspect
    13. public class LoggerAspect {
    14.     @Before("execution(public int org.example.aop.CalImpl.*(..))")
    15.     public void before(JoinPoint joinPoint){
    16.         String name = joinPoint.getSignature().getName();
    17.         System.out.println(name+"方法的参数是"+ Arrays.toString(joinPoint.getArgs()));
    18.     }
    19.  
    20.     @AfterReturning(value = "execution(public int org.example.aop.CalImpl.*(..))",returning = "result")
    21.     public void afterReturning(JoinPoint joinPoint,Object result){
    22.         String name = joinPoint.getSignature().getName();
    23.         System.out.println(name+"方法的结果是"+result);
    24.     }
    25. }

    2、实现类添加 @Component 注解

    1. package org.example.aop;
    2.  
    3. public interface Cal {
    4.     public int add(int num1, int num2);
    5.     public int sub(int num1, int num2);
    6.     public int mul(int num1, int num2);
    7.     public int div(int num1, int num2);
    8. }
    1. package org.example.aop;
    2.  
    3. import org.springframework.stereotype.Component;
    4.  
    5. @Component
    6. public class CalImpl implements Cal {
    7.  
    8.     @Override
    9.     public int add(int num1, int num2) {
    10.         int result = num1 + num2;
    11.         return result;
    12.     }
    13.  
    14.     @Override
    15.     public int sub(int num1, int num2) {
    16.         int result = num1 - num2;
    17.         return result;
    18.     }
    19.  
    20.     @Override
    21.     public int mul(int num1, int num2) {
    22.         int result = num1 * num2;
    23.         return result;
    24.     }
    25.  
    26.     @Override
    27.     public int div(int num1, int num2) {
    28.         int result = num1 / num2;
    29.         return result;
    30.     }
    31. }

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

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xmlns:context="http://www.springframework.org/schema/context"
    5.        xmlns:aop="http://www.springframework.org/schema/aop"
    6.        xmlns:p="http://www.springframework.org/schema/p"
    7.        xsi:schemaLocation="http://www.springframework.org/schema/beans
    8.        http://www.springframework.org/schema/beans/spring-beans.xsd
    9.        http://www.springframework.org/schema/context
    10.        http://www.springframework.org/schema/context/spring-context.xsd
    11.        http://www.springframework.org/schema/aop
    12.        http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
    13.     
    14.     <context:component-scan base-package="org.example.aop">context:component-scan>
    15.     
    16.     <aop:aspectj-autoproxy>aop:aspectj-autoproxy>
    17. beans>

    4、使用

    1. package org.example.test;
    2.  
    3. import org.example.aop.Cal;
    4. import org.springframework.context.ApplicationContext;
    5. import org.springframework.context.support.ClassPathXmlApplicationContext;
    6.  
    7. public class Test7 {
    8.     public static void main(String[] args) {
    9.         ApplicationContext context = new ClassPathXmlApplicationContext("spring2.xml");
    10.         Cal bean = context.getBean(Cal.class);
    11.         System.out.println(bean.add(9, 8));
    12.         System.out.println(bean.sub(9, 8));
    13.         System.out.println(bean.mul(9, 8));
    14.         System.out.println(bean.div(9, 8));
    15.     }
    16. }

    测试结果：

    相关视频：

    【2022版】2小时学会Spring核心机制IoC和AOP_哔哩哔哩_bilibili

  • 相关阅读:
    xLua Lua访问C#注意事项（七）
    【树莓派不吃灰】搭建Node-Red可拖拽图形化物联网
    前端HTML面试题：meta 元素都有什么
    知识图谱：信息抽取简易流程
    你是否还记得有一款游戏叫做“魔塔”？
    一站式采购！麒麟信安CentOS安全加固套件上架华为云云商店
    Linux编译链接选项静态库--whole-archive,--no-whole-archive
    python相关函数
    【ZYNQ】zynq启动模式及程序固化
    PostgreSQL 13支持增量排序(Incremental Sorting)
  • 原文地址：https://blog.csdn.net/weixin_55076626/article/details/127523272