初学者认识和书写Spring IoC 和AOP

已于 2023-11-19 19:34:55 修改
阅读量71 收藏
点赞数 3
文章标签： spring java 后端
于 2023-11-19 13:53:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wahahayou123456/article/details/134489925
版权

初学者认识和书写Spring IoC 和AOP

一、认识Spring

spring框架Java开发行业的标准

spring全家桶

例如：Web:Spring WebMVC/Spring MVC

持久层：Spring Data/Spring Data JPA、Spring Data Redis 、Spring Data MongoDB

安全校验：Spring Security

构建工程脚手架：Spring Boot

微服务：Spring Cloud

IoC是Spring全家桶各个功能模块基础， 创建对象的容器。

AOP也是以IoC为基础的，AOP是面向切面编程，抽象化的面向对象

用AOP思想做的应用有：（1）打印日志 （2）事务 （3）权限处理等

以打印日志为例：比如有很多的方法，在每个方法的开口会输出日志，在结尾我们也要输出一个日志，如果我们在每个方法上去写的话，我们代码的复用性就会很差，维护性、扩展性就不高，所以我们就会想到将输出日志的操作进行统一处理，也就是对这三个方法的位置进行统一处理（也就是面向切面的形式），就相当于用一把长的刀将三个西瓜横切一刀，这是就会切出一个水平面，然后我们将三个水平面抽象成一个对象，对这个对象进行编程，就相当于对这三个方法同时进行编辑。

二、认识Spring IoC

1.概念：

控制反转，将对象的创建进行反转，常规情况下，对象都是开发者手动创建的，使用IoC开发者不再需要创建对象，而是由IoC容器更具需求自动创建项目所需要的对象。（也就是说我们不用创建对象了，往大的说就是我们在使用框架的时候所有的组件都是自动创建、组装好的，我们直接用就可以了）

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

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

2.举例说明：
2.1创建工程，在pom.xml中引入依赖
 

<dependency> 
    <groupId>org.springframework</groupId> 
    <artifactId>spring-context</artifactId>
    <version>5.3.6</version>
 </dependency>
//作用：在类中加入@Data注解它自动生成类的get/set方法以及toString方法等
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.22</version>
</dependency>
 

2.2创建一个类DataConfig
 

package com.gcxy.ioc;
​
import lombok.Data;
​
@Data
public class DataConfig {
    private String url;
    private String driverName;
    private String userName;
    private String password;
​
}
 

使用Spring创建对象有两种方式：基于注解和XML的方式（大部分是注解）
 

基于XML：
 

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

（1）在resources包中创建配置文件，命名为spring.xml
 

<?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.gcxy.ioc.DataConfig" id="config">
       <property name="driverName" value="Driver"></property>
       <property name="url" value="localhost:8888"></property>
       <property name="userName" value="root"></property>
       <property name="password" value="123456"></property>
    </bean>
​
</beans>
 

（2）创建一个Test类
 

package com.gcxy.ioc;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {    
    public static void main(String[] arg){
    //DataConfig dataConfig = new DataConfig();
    //dataConfig.setUrl("localhost:3306/dbname");
    //dataConfig.setUserName("root");
    //dataConfig.setDriverName("druver");
    //dataConfig.setPassword("123456");                
    ApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");             
System.out.println(context.getBean("config"));    
    }
}
 

Spring在启动的时候通过xml解析首先把配置文件的数据拿出来（也就是xml中的<bean>中的数据），然后通过反射机制也就是DataConfig创建对象，再通过<property>方式将属性值赋进去（通过set/get方法）
 

结果如下：
 

 

基于注解
 

（一）配置类：用一个java类来替代xml文件，把在XML配置的内容放到配置类中
 

（1）创建一个名为BeanConfiguration的类，这个类就相当于xml文件中的配置
 

package com.gcxy.configuration;
import com.gcxy.ioc.DataConfig;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
@Configuration
public class BeanConfiguration {    
    @Bean   
    public DataConfig dataConfig(){        
        DataConfig dataConfig = new DataConfig();   
        dataConfig.setUrl("localhost:3306/dbname");
        dataConfig.setUserName("root");       
        dataConfig.setDriverName("druver");      
        dataConfig.setPassword("123456");       
        return dataConfig;    
    }
}
 

（2）将Test类改为
 

ApplicationContext context = new AnnotationConfigApplicationContext(BeanConfiguration.class);
//System.out.println(context.getBean(DataConfig.class));     
System.out.println(context.getBean("dataConfig"));
 

其中BeanConfiguration中的默认值是dataConfig方法名，也可以直接在BeanConfiguration中定义，直接在@Bean后面加一个方法名变为@Bean(value="config")或@Bean(name="config")
 

然后将Test类改为
 

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

当配置类很多时我们就指定包名就可以了
 

ApplicationContext context = new AnnotationConfigApplicationContext("com.gcxy.configuration");
System.out.println(context.getBean("dataConfig"));
 

运行后得到的结果与上图一样
 

（二）扫包+注解：更简单，不再依赖于XML文件或者配置类，而是直接将bean的创建交给目标类，在目标类中添加注解来创建
 

（1）将DataConfig类改为
 

package com.gcxy.ioc;
import lombok.Data;
import org.springframework.stereotype.Component;
@Data
@Component
public class DataConfig {    
    private String url;    
    private String driverName;    
    private String userName;    
    private String password;
}
 

其中@Component注解的作用就是告诉Spring框架现在这个DataConfig类是需要被注入到IoC的，当Spring读到这个类的时候发现这个注解他就会创建这个类对象，放到IoC里面。
 

@Component注解就相当于BeanConfiguration类中的代码都有了，它自己创建的。
 

（2）将Test类改为
 

ApplicationContext context = new AnnotationConfigApplicationContext("com.gcxy.ioc");
System.out.println(context.getBean(DataConfig.class));
 

但是这样运行之后没有值
 

 

那么我们应该怎样赋值呢，当然也是加注解
 

（3）在DataConfig类中加入@value("值")
 

package com.gcxy.ioc;
import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Data
@Componentpublic class DataConfig {    
    @Value("localhost:3306/dbname")    
    private String url;    
    @Value("driver")    
    private String driverName;    
    @Value("root")    
    private String userName;    
    @Value("123456")    
    private String password;
}
 

赋值后再运行结果就变为
 

 

IoC不仅可以自动创建对象，还可以完成依赖注入
 

（三）IoC的依赖注入：如：A里面有个B的对象，我们创建A和B两个对象，然后自动的将B装入A里面
 

（1）创建一个GlobalConfig类
 

package com.gcxy.ioc;
import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
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    
    private DataConfig dataConfig;
}
 

其中@Autowired自动装载，自动从IoC中去找DataConfig的bean，如果能找到就会将值赋给dataConfig
 

（2）再改变Test
 

ApplicationContext context = new AnnotationConfigApplicationContext("com.gcxy.ioc");
System.out.println(context.getBean(GlobalConfig.class));
 

这时候运行就能够将dataConfig类的值赋到GlobalConfig中
 

 

@Autowired通过类型进行注入，如果需要通过名称取值，则需要加入另外的注解@Qualifier("名称")以及在DataConfig类中@Component后进行命名，通过@Qualifier注解来完成名称的映射
 

（3）将GlobalConfig类改为
 

package com.gcxy.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 dataConfig;
}
 

三、认识Spring AOP
 

1.概念：
 

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

AOP的思想是把很多类对象中的横切问题点从业务逻辑中分离出来，从而达到解耦的目的，增强代码的重用性、提高代码的开发效率。
 

AOP最早由AOP组织联盟提出
 

2.AOP
 

2.1AOP的产生
 

很多类对象和Logger仍然存在依赖关系，甚至每个类的所有方法都需要调用Logger，如果修改了方法，需要修改N遍，不能一次性修改完成改变，为了解决这一问题，所以才有了AOP的产生
 

2.2AOP的应用场景
 

日志记录、异常处理、权限验证、缓存处理、事务处理、数据持久化、效率检查、内容分发
 

2.3AOP中术语主要的概念和理解
 

●aspect: 切面，切面有切点和通知组成，即包括横切逻辑的定义 也包括连接点的定义pointcut:切点，每个类都拥有多个连接点，可以理解是连接点的集合
 

●joinpoint: 连接点，程序执行的某个特定位置，如某个方法调用前后等
 

●weaving:织入，将增强添加到目标类的具体连接点的过程
 

●advice: 通知，是织入到目标类连接点上的一段代码，就是增强到什么地方?增强什么内容?target:目标对象，通知织入的目标类
 

●aop Proxy:代理对象，即增强后产生的对象
 

Spring AOP底层实现，是通过JDK动态代理或CGLib代理在运行时期在对象初始化阶段织入代码的。 JDK动态代理：基于接口
 

CGLib代理：基于类的继承
 

2.4通知
 

Before advice
 

前置通知：在目标方法调用前执行，注意：无论方法是否遇到异常都执行
 

After returning advice
 

后置通知：在目标方法调用后执行，前提是目标方法没有遇到异常，否则不执行
 

After throwing advice
 

异常通知，在目标方法抛出异常时执行，可以获取异常信息
 

After finally advice
 

最终通知，在目标方法执行后执行，无论是否异常都执行
 

Around advice
 

环绕通知，最强大的通知类型，可以控制目标方法执行（通过调用ProceedingJoinPoint.proceed()）,可在目标执行全过程中执行。
 

3.举例说明：
 

例如打印日志
 

业务代码和打印日志耦合起来
 

 

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

 

从此图中可以看出一个计算器（目标类）与一个切面对象组成一个代理对象，我们可以直接在这个代理对象中进行编码，得到想要的结果
 

未解耦合时，日志和业务是合在一起的
 

package com.gcxy.aop;

public class CalImp implements Cal{
    @Override
    public int add(int num1, int num2) {
        System.out.println("add方法的参数是["+num1 + "," +num2 +"]");
        int reult = num1 + num2;
        System.out.println("add方法的结果是" +reult);
        return reult;
    }

    @Override
    public int sub(int num1, int num2) {
        System.out.println("sub方法的参数是["+num1 + "," +num2 +"]");
        int reult = num1 - num2;
        System.out.println("sub方法的结果是" +reult);
        return reult;
    }

    @Override
    public int mul(int num1, int num2) {
        System.out.println("mul方法的参数是["+num1 + "," +num2 +"]");
        int reult = num1 * num2;
        System.out.println("mul方法的结果是" +reult);
        return reult;
    }

    @Override
    public int div(int num1, int num2) {
        System.out.println("div方法的参数是["+num1 + "," +num2 +"]");
        int reult = num1 / num2;
        System.out.println("div方法的结果是" +reult);
        return reult;
    }
}
 

下面我们来创建解耦后的代码
 

（1）在pom.xml中加入切面依赖
 

<dependency>  
    <groupId>org.springframework</groupId>                    
    <artifactId>spring-aspects</artifactId>                     
    <version>5.3.6</version>
</dependency>
 

（2）创建切面类LoggerAspect
 

package com.gcxy.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.gcxy.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.gcxy.aop.CalImpl.*(..))",returning = "result")    
    public void afterReturn(JoinPoint joinPoint,Object result){        
        String name = joinPoint.getSignature().getName();        
        System.out.println(name+"方法的结果是"+result);    
    }
}
 

（3）实现类添加@Component注解
 

package com.gcxy.aop;

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

（4）配置自动扫包，开启自动生成代理对象
 

在pom.xml中添加
 

<!--  自动扫包  -->    
<context:component-scan base-package="com.gcxy.aop"></context:component-scan>
<!--    开启自动代理-->   
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
 

（5）使用：创建测试类Test
 

package com.gcxy.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));
    }
}
 

（6）运行结果：
 

 

因为一个目标对象对应一个切面类，当有多个目标对象时想要输出结果则需要只保留一个目标对象，可以将其余目标对象的@Component注解注释掉就可以正常运行得到你想要的结果

                

        

        

    




    

      

        

            

              
                
                  测试道路探索中
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    3
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                  1
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










              

  



          




        



    





    



      

      

        
      

      





	

		
评论 1

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值