什么是IOC和什么是AOP

已于 2022-10-29 18:01:47 修改
阅读量1.3k 收藏 9
点赞数 4
文章标签： java spring ioc aop
于 2022-10-26 00:24:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55076626/article/details/127523272
版权

什么是IOC

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

相关依赖：

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

案例：

随便创建一个实体类：

package org.example.pojo;

import lombok.Data;
import lombok.experimental.Accessors;

@Data
@Accessors(chain = true)
public class DataConfig {

    private String ip;

    private String dataBaseName;

    private String userName;

    private String pwd;
}

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

测试：

package org.example.test;

import org.example.pojo.DataConfig;

public class Test {
    public static void main(String[] args) {
        DataConfig dataConfig = new DataConfig();
        dataConfig.setIp("127.0.0.1")
                .setDataBaseName("test")
                .setUserName("root")
                .setPwd("ok");
        System.out.println(dataConfig);
    }
}

测试结果：

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

一、基于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:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       https://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
    <bean class="org.example.pojo.DataConfig" id="config">
        <property name="ip" value="127.0.0.1" />
        <property name="dataBaseName" value="test" />
        <property name="userName" value="root" />
        <property name="pwd" value="ok" />
    </bean>
</beans>

测试：

package org.example.test;

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

public class Test2 {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        System.out.println(context.getBean("config"));
    }
}

测试结果：

二、基于注解：

1、配置类

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

package org.example.configuration;

import org.example.pojo.DataConfig;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class BeanConfiguration {
    
    @Bean(value = "config")
    public DataConfig dataConfig(){
        DataConfig dataConfig = new DataConfig();
        dataConfig.setIp("127.0.0.1")
                .setDataBaseName("test")
                .setUserName("root")
                .setPwd("ok");
        return dataConfig;
    }
}

测试：

package org.example.test;

import org.example.configuration.BeanConfiguration;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Test3 {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(BeanConfiguration.class);
        System.out.println(context.getBean("config"));
    }
}

 测试结果：

2、扫包+注解

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

package org.example.pojo;

import lombok.Data;
import lombok.experimental.Accessors;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Data
@Component
@Accessors(chain = true)
public class DataConfig2 {

    @Value("127.0.0.1")
    private String ip;

    @Value("test")
    private String dataBaseName;

    @Value("root")
    private String userName;

    @Value("ok")
    private String pwd;
}

测试：

package org.example.test;

import org.example.pojo.DataConfig2;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Test4 {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext("org.example.pojo");
        System.out.println(context.getBean(DataConfig2.class));
    }
}

测试结果：

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

package org.example.pojo;

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 DataConfig2 dataConfig2;
}

测试：

package org.example.test;

import org.example.pojo.GlobalConfig;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Test5 {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext("org.example.pojo");
        System.out.println(context.getBean(GlobalConfig.class));
    }
}

测试结果：

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

package org.example.pojo;

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 GlobalConfig2 {
    @Value("8080")
    private String port;
    @Value("/")
    private String path;
    @Autowired
    @Qualifier("config")
    private DataConfig2 dataConfig2;
}

测试：

package org.example.test;

import org.example.pojo.GlobalConfig2;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Test6 {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext("org.example.pojo");
        System.out.println(context.getBean(GlobalConfig2.class));
    }
}

测试结果：

什么是AOP

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

相关依赖：

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

应用场景：

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

案例：

1、创建切面类

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

2、实现类添加 @Component 注解

package org.example.aop;

public interface Cal {
    public int add(int num1, int num2);
    public int sub(int num1, int num2);
    public int mul(int num1, int num2);
    public int div(int num1, int num2);
}

package org.example.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="org.example.aop"></context:component-scan>
    <!-- 开启自动生成代理 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

4、使用

package org.example.test;

import org.example.aop.Cal;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test7 {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring2.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));
    }
}

测试结果：

相关视频：

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

长头发的程序猿
关注
  • 4
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
IOC和AOP
weixin_73667562的博客
04-03 5905
IOC，即，把对象的创建、初始化、销毁交给 Spring 来管理，而不是由开发者控制，实现控制反转。IOC 思想基于 IOC 容器完成，IOC 容器底层就是对象工厂（BeanFactory 接口）。IOC的原理是基于xml解析、工厂设计模式、反射实现的。。
Spring的AOP和IOC是什么？
qq_43582619的博客
01-24 1万+
1.AOP（Aspect Oriented Programming） 也叫做------面向切面编程。是一种通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码（性能监视、事务管理、安全检查、缓存）。AOP面向方面编程基于IoC，是对OOP的有益补充。 AOP利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了 多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即方面。所谓“方面”，简单地说，就是将那些..
Spring IOC 和 AOP
最新发布
ZhShH0413的博客
04-29 1168
Spring框架中的IoC（Inverse of Control，控制反转）和AOP（Aspect-Oriented Programming，面向切面编程）是其两大核心特性，它们共同为Java应用程序带来了更高的灵活性、可维护性和松耦合度。
AOP和IOC
cpy1356140308的博客
05-11 1133
在Spring框架中，IOC是通过将对象的创建、组装和管理交由容器实现的，通过配置文件或注解来描述对象之间的依赖关系和容器的行为。提高系统的灵活性，通过容器来管理对象的创建和生命周期，可以在运行时动态地更改对象之间的依赖关系和配置信息，从而实现系统的灵活性和可配置性。提高系统的可测试性，通过将对象的创建和依赖关系交由容器管理，可以方便地进行单元测试和集成测试，从而提高系统的可测试性和可靠性。提高代码复用性和可维护性，将系统的业务逻辑和非业务逻辑分离开来，降低代码的耦合度，避免代码的重复编写和维护。
spring框架两大核心：IOC和AOP的详解
qq_49755675的博客
07-06 9472
IOC和AOP的详解。
Spring两大核心思想：IOC和AOP
m0_73381672的博客
02-19 1217
1.先自定义一个注解@Target(ElementType.METHOD) //作用范围 此处是方法@Retention(RetentionPolicy.RUNTIME) //生命周期 此处是运行时2.在切点表达式中加入该注解@Aspect@Component@Slf4j@Around("@annotation(com.example.demo.aspect.TestAnnotation)") //此处加自定义注解log.info("around继续");try {
SpringIOC和AOP原理设计模式
01-27
Spring框架的核心特性主要体现在Spring的IOC（Inversion of Control，控制反转）和AOP（Aspect-Oriented Programming，面向切面编程）上。这两个概念在实际的软件开发中扮演着非常重要的角色，能够极大地提高代码的...
springioc和spring aop
09-05
Spring框架是Java开发中不可或缺的一部分，它通过提供两种核心特性——控制反转（IoC）和面向切面编程（AOP）来简化应用的构建。理解并掌握这两种技术对于任何Java开发者来说都至关重要。 **控制反转（IoC）**，也...
Spring核心IoC和AOP的理解
08-31
Spring核心IoC和AOP的理解 本文主要介绍了Spring核心IoC和AOP的相关知识，涵盖了IoC和AOP的概念、特点、优点和应用场景等方面的内容。 一、IoC（Inversion of Control） IoC是一种设计模式，目的是为了降低应用...
Spring 的IOC和AOP特点
09-15
Spring的核心:IOC与AOP。IOC是控制反转或依赖注入,AOP是面向切面编程。
Spring IOC和aop的原理及实例详解
08-25
Spring IOC和AOP的原理及实例详解 在软件开发中，控制反转（IOC）和面向切面编程（AOP）是两种非常重要的设计模式。Spring框架正是基于这两种模式的思想设计的。下面我们将详细介绍Spring IOC和AOP的原理及实例详解...
Spring中IOC和AOP的详细解释
三也_攻城狮
08-29 8468
我们是在使用Spring框架的过程中，其实就是为了使用IOC，依赖注入，和AOP，面向切面编程，这两个是Spring的灵魂。 主要用到的设计模式有工厂模式和代理模式。 IOC就是典型的工厂模式，通过sessionfactory去注入实例。 AOP就是典型的代理模式的体现。 代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消
什么是IOC 和 AOP?
weixin_43824520的博客
08-27 5400
什么是 IOC IoC （Inversion of control ）控制反转/反转控制。它是一种思想不是一个技术实现。描述的是：Java 开发领域对象的创建以及管理的问题。 例如：现有类 A 依赖于类 B 传统的开发方式 ：往往是在类 A 中手动通过 new 关键字来 new 一个 B 的对象出来 使用 IoC 思想的开发方式 ：不通过 new 关键字来创建对象，而是通过 IoC 容器(Spring 框架) 来帮助我们实例化对象。我们需要哪个对象，直接从 IoC 容器里面过去即可。 从以上两种开发
面试官：谈谈你对IOC和AOP的理解及AOP四种实现方式
热门推荐
小样yx的博客
05-17 4万+
一、AOP介绍 面向切片编程（AOP—Aspect Oriented Programming）可以说是对OOP（面向对象编程）的补充和完善，面向对象就是将事物的特性和行为抽象为一个对象，如people类有身高、体重、年龄等属性，也有吃饭、睡觉等行为。把这些特性和行为封装成一个类，然后可以统一调用。面向切片也可以举个例子，比如people类有自己的属性和行为，但是有小一部分人生病要去医院看病，看病这个业务逻辑就不属于哪一个类，因为people泛指所有人，所有人不会都看病。AOP就是把医院看病这一个业务逻辑功能
AOP与IOC概念
笨笨熊咦
02-26 5542
AOP与IOC的概念（即spring的核心）1.IOC：Spring是开源框架，使用框架可以使我们减少工作量，提高工作效率并且它是分层结构，即相对应的层处理对应的业务逻辑，减少代码的耦合度。而spring的核心是IOC控制反转和AOP面向切面编程。IOC控制反转主要强调的是程序之间的关系是由容器控制的，容器控制对象，控制了对外部资源的获取。而反转即为，在传统的编程中都是由我们创建对象获取依赖对象，...
面试被问了几百遍的 IoC 和 AOP，还在傻傻搞不清楚？
m0_63437643的博客
05-18 469
如果只有一个类引用了IUserDao的具体实现，可能觉得还好，修改起来也不是很费力气，但是如果有许许多多的地方都引用了IUserDao的具体实现的话，一旦需要更换IUserDao 的实现方式，那修改起来将会非常的头疼。这样将会少些很多重复的代码。使用 IoC 的思想，我们将对象的控制权（创建、管理）交有 IoC 容器去管理，我们在使用的时候直接向 IoC 容器 “要” 就可以了。代码拆分比较容易，难的是如何在不改变原有业务逻辑的情况下，悄无声息的将横向逻辑代码应用到原有的业务逻辑中，达到和原来一样的效果。
Spring中的IOC和AOP是什么意思？
weixin_45704311的博客
04-20 1万+
(1) Spring是什么？ IOC(控制反转)和AOP(面向方面编程)作为Spring框架的两个核心，很好地实现了解耦合。所以，简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。 spring的基本框架主要包含六大模块：DAO、ORM、AOP、JEE、WEB、CORE Spring DAO：Spring提供了对JDBC的操作支持：JdbcTemplate模板工具类 。 Spring ORM：Spring可以与ORM框架整合。例如Spring整...
请简述什么是ioc和AOP
06-09
IOC（Inversion of Control，控制反转）是一种设计思想，它的核心思想是将对象的创建、依赖注入、生命周期管理等...AOP 通过将应用程序分解为不同的关注点，从而使得这些关注点可以独立地进行开发、测试、维护和重用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值