Spring IoC和AOP

最新推荐文章于 2023-06-26 15:00:21 发布

haven-852

最新推荐文章于 2023-06-26 15:00:21 发布

阅读量130

点赞数 1

分类专栏： Spring 文章标签： spring java spring boot

本文链接：https://blog.csdn.net/qq_40500099/article/details/124935758

版权

Spring 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Spring框架java开发的行业标准

Spring全家桶
Web：Spring Web MVC/Spring MVC/Spring Web Flux
持久层：Spring Data/Spring Data Jpa/Spring Data Redis/Spring Data MongoDB
安全检验：SpringSecurity
构建工程脚手架：Spring Boot
微服务：Spring Cloud
IOC是Spring全家桶各个功能模块的基础，创建对象的容器。
AOP也是以IOC为基础，AOP是面向切面编程，抽象化的面向对象。

打印日志
事务
权限处理

1.1 Ioc

控制反转，将对象的创建进行反转，常规情况下，对象都是开发者手动创建的，使用Ioc开发者不再需要创建对象，而是由Ioc容器根据需求自动创建项目所需要的对象。
不用Ioc：所有对象开发者自己创建
使用Ioc：对象不用开发者创建，而是交给Spring框架来完成

创建Maven项目：

1、pom.xml

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

会出现这种报错的情况
在这里插入图片描述
这时需要往pom.xml文件中引入下列代码项目内引入

<build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

基于XML（用的不多）和基于注解
基于XML：开发者把需要的对象再XML中进行配置，spring框架读取这个配置文件，根据配置文件的内容来创建对象。
在这里插入图片描述
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.haven.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.haven.ioc;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args) {
    //context 就是IOC所附着的对象
        ApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");
        System.out.println(context.getBean("config"));
    }
}

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

package com.haven.configuration;

import com.haven.ioc.DataConfig;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
//成为配置类
public class BeanConfiguration {
    @Bean //插入构造方法，方便开发者使用。相当于IOC
    public DataConfig dataConfig(){
        DataConfig dataConfig=new DataConfig();
        dataConfig.setDriverName("Driver");
        dataConfig.setUrl("localhost:3306/dbname");
        dataConfig.setUsername("root");
        dataConfig.setPassword("root");
        return dataConfig;
    }
}

package com.haven.ioc;

import com.haven.configuration.BeanConfiguration;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args) {
        //通过读取XML文件来初始化IOC容器
        //ApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");
        //System.out.println(context.getBean("config"));
        //通过读取配置类来初始化IOC容器
        ApplicationContext applicationContext=new AnnotationConfigApplicationContext(BeanConfiguration.class);
        //通过加载BeanConfigura.class的方式来加载对应的配置类
        //但是会遇见配置包内有许多的配置类，一个一个加载会有点麻烦，所以就可以选择加载包
        //ApplicationContext applicationContext=new AnnotationConfigApplicationContext("com.haven.configuration");
        System.out.println(applicationContext.getBean("dataConfig"));
    }
}

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

package com.haven.ioc;
import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Data //生成get、set方法和创建构造函数
@Component  //告诉spring框架，这个类需要被注入到IOC当中的，当
            //spring读取到这个类的时候，有注解就标注了这个类需要被加载，所以就会创建这个类的对象
            //然后放到IOC的里面
public class DataConfig {
    @Value("localhost:3306")
    private String url;
    @Value("Driver")
    private String driverName;
    @Value("root")
    private String username;
    @Value("root")
    private String password;

}

package com.haven.ioc;

import com.haven.configuration.BeanConfiguration;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args) {
        //通过读取XML文件来初始化IOC容器
        //ApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");
        //System.out.println(context.getBean("config"));
        //通过读取配置类来初始化IOC容器
//        ApplicationContext applicationContext=new AnnotationConfigApplicationContext(BeanConfiguration.class);
//        System.out.println(applicationContext.getBean("dataConfig"));
        ApplicationContext context=new AnnotationConfigApplicationContext("com.haven.ioc");
        System.out.println(context.getBean(DataConfig.class));
    }
}

输出：
在这里插入图片描述
自动创建对象，完成依赖注入。
例如：
创建类GlobalConfig

package com.haven.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  //自动装配，会自动去ioc里面去找有DataConfig的类，如果能找到，就把值赋给到DataConfig
    private DataConfig dataConfig;
}

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

@Autowired 通过类型byType进行注入，如果需要通过名称byName取值

package com.haven.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  //自动装配，会自动去ioc里面去找有DataConfig的类，如果能找到，就把值赋给到DataConfig
    @Qualifier("config") //起名字的注解
    private DataConfig dataConfig;
}

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

package com.haven.ioc;
import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Data
@Component (value = "config")  //告诉spring框架，这个类需要被注入到IOC当中的，当
            //spring读取到这个类的时候，有注解就标注了这个类需要被加载，所以就会创建这个类的对象
            //然后放到IOC的里面
public class DataConfig {
    @Value("localhost:3306")
    private String url;
    @Value("Driver")
    private String driverName;
    @Value("root")
    private String username;
    @Value("root")
    private String password;

}

IOC总结：

功能：利用IOC来完成对象创建的功能
创建IOC的方法：
基于XML：配置XML文件（Bean），引入IOC容器
基于注解：（1）配置类：配置类=XML文件（在功能上相似）；（2）扫包+注解（应用最广且最为简单）：创建IOC容器时扫描包，利用注解@Component、@Autowired来创建类之间的关联。

1.2AOP

概念：面向切面编程，是一种抽象化的面向对象编程，对面向对象编程一种补充，底层使用动态代理机制。简单来说，就是把不影响业务的非业务大妈抽象出来。
例子：打印日志
业务代码和打印日志耦合起来，计算器方法中，日志和业务混合在一起，AOP要做的就是将日志代码全部抽象出去统一进行处理，计算器方法中只保留核心的业务代码。做到核心业务和非业务代码的解耦合。
在这里插入图片描述
1、创建切面类

package com.haven.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 {
    //CalImp里面所有的方法进行映射，在CalImp里面方法执行之前，去执行before里面的代码
    @Before("execution(public int com.haven.aop.CalImp.*(..))")
    public void before(JoinPoint joinPoint){
        //joinpoint就是目标方法和参数之间的连接
        String name=joinPoint.getSignature().getName();
        //joinpoint.getArgs就是获取对应参数
        System.out.println(name+"方法的参数是"+ Arrays.toString(joinPoint.getArgs()));

    }
    //returning是因为无法返回方法最后的结果，所以需要添加注解的方式来完成
    @AfterReturning(value = "execution(public int com.haven.aop.CalImp.*(..))",returning ="result" )
    public void afertReturning(JoinPoint joinPoint,Object result){
        String name=joinPoint.getSignature().getName();
        System.out.println(name+"方法的参数是"+ result);
    }
}

2、实现类添加@Component

package com.haven.aop;

import org.springframework.stereotype.Component;

@Component
public class CalImp 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.haven.aop"></context:component-scan>
        <!--开启自动生成代理-->
        <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

aop:aspectj-autoproxy</aop:aspectj-autoproxy>：切面自动代理
4、使用

package com.haven.aop;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args) {
    //通过配置文件来创建的IOC容器
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");
        Cal bean = applicationContext.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));

    }
}