Spring的两大核心（SpringIOC、SpringAOP）

于 2025-02-22 22:21:49 发布
阅读量657 收藏 14
点赞数 29
文章标签： spring java mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62859066/article/details/145797489
版权

一：SpringIOC

        IOC(中文释义：控制反转)，主要作用于解耦。IOC是指将创建对象的控制权交给spring框架进行管理，spring框架根据配置文件或注解等方式，创建bean对象并管理各个bean对象之家的依赖关系，使对象之间形成耦合松散的状态，实现解耦。

        控制：指的是对象创建（实例化、管理）的权力

        反转：控制权交给外部环境（spring框架、IOC容器）

IOC的使用：

（1）导入坐标

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

（2）将需要已解耦创建的对象，类注入springIOC容器

<bean id="类的唯一标识" class="注入的类"></bean>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="StudentDaoImpl" class="com.apesource.dao.StudentDaoImpl"></bean>

    <bean id="StudentserviceImpl" class="com.apesource.service.StudentserviceImpl"/>

    <bean id="Date" class="java.util.Date"> </bean>

</beans>

（3）向springIOC容器索取实例

package com.apesource.test;

import com.apesource.dao.IStudentDao;
import com.apesource.service.IStudentservice;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.Date;

public class Test {
    public static void main(String[] args){
        ApplicationContext context =new ClassPathXmlApplicationContext("beans.xml");
        IStudentDao dao=(IStudentDao) context.getBean("StudentDaoImpl");

        IStudentservice service =(IStudentservice) context.getBean("StudentserviceImpl");
        Date date=(Date) context.getBean("Date");
        System.out.println(date);
        service.save();
        dao.save();
    }
}

二：SpringDI（依赖注入）

        DI（依赖注入） 是对IOC概念的不同角度的描述，是指应用程序在运行时，每一个bean对象都依赖IOC容器注入当前bean对象所需要的另外一个bean对象。

1.DI的使用：

（1）提供set方法（或者构造方法）

package com.apesource.Controller;

import com.apesource.service.StudentServiceImpl;

public class StudentControllerImpl implements IStudentController{
    StudentServiceImpl service;

    public void setService(StudentServiceImpl service) {
        this.service = service;
    }

    @Override
    public void save() {
        System.out.println("controller的新增");
        service.save();
    }
}

（2）配置标签

语法：<property name="属性名" ref="关联的id"></property>

位置：<bean>此位置</bean>

<bean id="StudentControllerImpl" class="com.apesource.Controller.StudentControllerImpl">
    <property name="service" ref="StudentServiceImpl"></property>
 </bean>

2.DI注入方式

        A.set注入

        B.构造注入

构造注入即为将set方法改为构造方法即可。

3.DI注入数据类型

        A.基本类型与String

        B.javaBean对象

        C.复杂类型

复杂类型包括：list、set、String[]、map、properties

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">


    <bean id="StudentControllerImpl" class="com.apesource.Controller.StudentControllerImpl">
        <property name="service" ref="StudentServiceImpl"></property>
     </bean>

    <bean id="student" class="com.apesource.bean.Student">
        <property name="name" value="蜡笔小新"></property>
        <property name="age" value="10"></property>
        <property name="hobby" value="玩玩具"></property>
    </bean>

    <bean id="teacher" class="com.apesource.bean.Teacher">
        <property name="list">
            <list>
                <value>哪吒2</value>
                <value>唐探</value>
                <value>熊出没重启未来</value>
                <value>封神2</value>
                <value>射雕英雄传</value>
            </list>
        </property>
        <property name="set">
            <set>
                <value>西安</value>
                <value>宝鸡</value>
                <value>郑州</value>
                <value>兴平</value>
                <value>延安</value>
            </set>
        </property>
    </bean>

</beans>

三SpringAOP

AOP(Aspect-Oriented Programming: 面向切面编程)：将那些与业务无关，却为业务模块所共同调用的逻辑（例如事务处理、日志管理、权限控制等）封装抽取成一个可重用的模块，这个模块被命名为“切面”（Aspect），便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可拓展性和可维护性；

Spring AOP 基于动态代理实现：

○ 如果被代理的对象，已经实现某个接口，则 Spring AOP 会使用 JDK Proxy（反射），基于接口的方式，创建代理对象（JDK动态代理的核心是InvocationHandler接口和Proxy类）；

○ 如果被代理的对象，没有实现某个接口，就无法使用 JDK Proxy 去进行代理了，这时候 Spring AOP 会使用 Cglib，基于继承的方式，生成一个被代理对象的子类来作为代理（Cglib动态代理的核心是MethodInterceptor接口和Enhancer类）;

（1）AOP的通知类型

AOP将抽取出来的共性功能称为通知;通知类型:以通知在上下文中的具体位置作为划分

        前置通知（Before）

        后置通知（After）

        返回通知（After-returning）

        异常通知（After-throwing）

        环绕通知（Around）

（2）AOP连接点(Join point)

AOP将所有的方法都视为连接点，不管是接口里面的抽象方法,还是实现类里面的重写方法，都是连接点。

AOP切点(Pointcut)

AOP将可能被抽取共性功能的方法称为切入点。切入点是连接点的子集

AOP目标对象(Target): 就是挖掉功能的方法对应的类生的对象，这种对象是无法直接完成最终工作的。

AOP织入(Weaving):就是将挖掉的功能回填的动态过程

（3）AOP切面:切点+通知

1.添加依赖，aop与aspectj表达式的依赖

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.8.7</version>
</dependency>

2.创建spring的主配置文件，bean内的命名空间要添加aop的

3.创建业务代码并编写日志记录代码(事务管理代码)

4.将业务层与日志记录层注入spring容器

5.<aop:config>--aop配置

        aop:aspect--aop切面

        aop:before--通知内容与通知类型

切点表达式配置语法：

execution(修饰符 返回值 包名称.类名称.方法名称(参数列表))

eg:

execution(public void com.apesource.service.ServiceImp.findAll())

1.修饰符可以省略代表任意

        execution(返回值 包名称.类名称.方法名称(参数列表))

2.返回值可以使用“*”代表任意

        execution(* 包名称.类名称.方法名称(参数列表))

3.包名可以使用“*”代表任意名称

        execution(* *.*.*.类名称.方法名称(参数列表))

4.包名可以使用“..”代表任意个数

        execution(* *...类名称.方法名称(参数列表))

5.类名与方法名可以使用“*”代表任意

        execution(* *...*.*(参数列表))

6.参数列表可以使用".."代表任意个数任意类型

        execution(* *...*.*(..))

如果有参数

int======>int

String===>java.lang.String

<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="service" class="com.apesource.service.CountServiceImpl"></bean>
    <bean id="logger" class="com.apesource.util.Logger"></bean>
    <!--配置Aop-->
    <aop:config>
        <!--配置切面-->
        <aop:aspect id="aopAspect" ref="logger">
            <!--配置切点-->
            <aop:pointcut id="pointCut" expression="execution(* com.apesource.service.*.*(..))"></aop:pointcut>
<!--            &lt;!&ndash;前置通知&ndash;&gt;-->
<!--            <aop:before method="beforeLogger" pointcut-ref="pointCut"></aop:before>-->
<!--            &lt;!&ndash;返回通知&ndash;&gt;-->
<!--            <aop:after-returning method="returnLogger" pointcut-ref="pointCut"></aop:after-returning>-->
<!--            &lt;!&ndash;异常通知&ndash;&gt;-->
<!--            <aop:after-throwing method="throwLogger" pointcut-ref="pointCut"></aop:after-throwing>-->
<!--            &lt;!&ndash;后置通知&ndash;&gt;-->
<!--            <aop:after method="afterLogger" pointcut-ref="pointCut"></aop:after>-->
            <aop:around method="aroundLogger" pointcut-ref="pointCut"></aop:around>
        </aop:aspect>
    </aop:config>
</beans>
package com.apesource.util;

import org.aspectj.lang.ProceedingJoinPoint;

public class Logger {
    public void beforeLogger(){
        System.out.println("日志类logger中调用前置通知进行日志记录");
    }
    public void returnLogger(){
        System.out.println("日志类logger中调用返回通知进行日志记录");
    }
    public void throwLogger(){
        System.out.println("日志类logger中调用异常通知进行日志记录");
    }
    public void afterLogger(){
        System.out.println("日志类logger中调用后置通知进行日志记录");
    }

    public Object aroundLogger(ProceedingJoinPoint pjp){
        Object obj = null;
        try {
            System.out.println("环绕通知的前置通知");
            obj =pjp.proceed(pjp.getArgs());
            System.out.println("环绕通知的返回通知");
        } catch (Throwable e) {
            e.printStackTrace();
            System.out.println("环绕通知的异常通知");
        }finally {
            System.out.println("环绕通知的后置通知");
        }
        return obj;
    }
}

Spring框架的两大核心思想
Json_book的博客
12-08 2389
关于spring的容器的思想汇总
深入理解Spring的两大特征（IOC和AOP）
热门推荐
Vision
04-05 8万+
众所周知，Spring的核心特性就是IOC和AOP，IOC（Inversion of Control），即“控制反转”；AOP（Aspect-OrientedProgramming），即“面向切面编程”。参考书《Spring In Action》，下面分享一下我对这两大特性的个人理解。IOC：IOC，另外一种说法叫DI（Dependency Injection），即依赖注入。它并不是一种技术实现，而
spring两大核心
chenyl
02-21 3194
spring有两大核心 1 第一大核心，ioc（inversion of control）控制反转，让一个对象的产生不用再依靠代码new，而是通过java 反射技术动态的去创建调用对象，spring运行后通过加载xml配置文件来动态的创建对象和调用对象里的方法。 2 第二大核心，aop（Aspect oriented programing）面向切面编程，这是一种程序设计的规范，以一种称为切面语
Spring中的两大核心
keep12moving的博客
09-17 558
Spring是什么？ spring是J2EE应用程序框架，是轻量级的IoC和AOP的容器框架(相对于重量级的EJB)，主要是针对javaBean的生命周期进行管理的轻量级容器，可以单独使用，也可以和Struts框架，ibatis框架等组合使用。 IOC(Inversion of Control )或DI(Dependency Injection) IOC控制权反转 ...
spring的两大核心
回首一辈子
10-24 5021
IOC 将类的创建和依赖关系写在配置文件里，由配置文件注入，实现了松耦合 控制反转：将对象的控制权从代码（new）交给xml AOP 将安全，事务等于程序逻辑相对独立的功能抽取出来，利用spring的配置文件将这些功能插进去， 面向切面：在不影响原有代码基础上，植入功能，例如：打印日志 ...
Spring两大核心思想：IOC和AOP
m0_73381672的博客
02-19 2303
1.先自定义一个注解@Target(ElementType.METHOD) //作用范围 此处是方法@Retention(RetentionPolicy.RUNTIME) //生命周期 此处是运行时2.在切点表达式中加入该注解@Aspect@Component@Slf4j@Around("@annotation(com.example.demo.aspect.TestAnnotation)") //此处加自定义注解log.info("around继续");try {
Spring IOC和Spring AOP_spring aop_springIOC
09-24
Spring框架是Java开发中最常用的轻量级框架之一，它的核心特性包括依赖注入（Dependency Injection，简称DI）和面向切面编程（Aspect-Oriented Programming，简称AOP）。这两个概念是Spring框架的基石，极大地简化了...
【JavaEE框架】Spring核心技术详解：IoC、AOP、Bean管理及数据访问设计
最新发布
04-12
Spring是一个轻量级Java开发框架，旨在简化Java开发，其核心特性为控制反转（IoC）和面向切面编程（AOP）。文章详细阐述了IoC的原理和实现方式，包括依赖注入的多种实现方式（如setter注入、构造方法注入、注解注入...
Spring核心IoC和AOP的理解
08-31
Spring核心IoC和AOP的理解 本文主要介绍了Spring核心IoC和AOP的相关知识，涵盖了IoC和AOP的概念、特点、优点和应用场景等方面的内容。 一、IoC（Inversion of Control） IoC是一种设计模式，目的是为了降低应用...
tiny-spring-practice:实践tiny-spring，手写Spring两大核心功能：IOC和AOP
05-13
最近想深入学习一下Spring的两大核心功能：IOC、AOP。想看源码但是Spring的源码层次复杂，封装繁琐，简单的逻辑写的非常“啰嗦”，阅读起来很费劲。然后发现了多年前的一个精简版的Spring学习项目，叫，作者对spring...
初识Spring~
Rok728的博客
08-13 271
1.官网 http://spring.io 2.概述 Spring是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。Spring框架的不光是技术牛，而是它的核心思想更牛，它不重复发明轮子，而是"拿来主义"，把业界做的最好的技术黏合起来形成一个强大的企业级的应用框架。 Spring 框架是一个分层架构，由7个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式，如下图所示： 组成 Spring 框架的每个模块（或组件）都可以单独存在..
Spring两大核心IOC、AOP
Good_omen的博客
03-29 413
Spring两大核心IOC、AOP 简介 ​ Spring 是分层的 Java SE/EE 应用 full-stack 轻量级开源框架，以IOC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 Spring MVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的 Java EE 企业应用开源框架。 优点 方便解耦
Spring的两大核心技术
baimin7657的专栏
03-30 1817
Bean工厂和AOP框架
Spring的两大核心概念
春日部小学森的博客
12-12 1247
Spring框架的两大核心是与控制反转指的是将对象的创建和依赖注入由应用代码转移到了Spring容器中进行，即由Spring容器负责创建对象和管理它们之间的依赖关系。这样，应用代码只需要关注业务逻辑的实现，而不需要关注对象的创建和管理，降低了应用代码的复杂度，提高了代码的可重用性和可维护性。其中作为Spring框架中的一种设计模式，用于实现控制反转。它是一种将对象之间的依赖关系从硬编码中解耦的方法。
spring框架两大核心
m0_60561899的博客
10-10 2862
ioc 与 di IOC（Inversion of control）简单来说就是将对象object 的创建的权利及对象的生命周期的管理过程交由spring框架来处理。从此再开发过程中不需要关注对象的创建和生命周期的管理，而是在需要的时候由spring框架提供，这个由spring框架管理对象创建和生命周期的机制称之为控制反转 DI（Dependency Injection）依赖注入，在创建对象的过程中spring可以依据对象的关系，自动把其他对象注入（无需创建对象，直接拿着使用） 总结 spring核心
Spring的两大核心思想总结
qq_62283164的博客
08-10 1202
使对象之间形成松散耦合的关系,实现解耦;AOP ( Aspect -Oriented Programing :面向切面编程):将那些与业务无关,却为业务模块所共同调用的逻辑(例如事务处理、日志管理、权限控制等)封装抽取成一个可重用的模块，这个模块被命名为“切面”( Aspect )， 便于减少系统的重复代码,降低模块间的耦合度,并有利于未来的可拓展性和可维护性;如果被代理的对象，已经实现某个接口，则Spring AOP会使用JDK Proxy (反射) , 基于接口的方式，创建代理对象；
浅谈spring核心
weixin_43500974的博客
06-07 509
我们都知道spring的两大核心是：IoC（控制反转）和AOP（面向切面编程）；还有现在微服务时期，springCloud,springBoot，spring三者的关系；本文主要想阐述一下对这两个问题的理解，如有错误，恳请指正；
Spring中的两大核心都是什么？
sinat_41920065的博客
07-10 9298
spring是J2EE应用程序框架，是轻量级的IoC和AOP的容器框架(相对于重量级的EJB)，主要是针对javaBean的生命周期进行管理的轻量级容器，可以单独使用，也可以和Struts框架，ibatis框架等组合使用。 1、IOC(Inversion of Control )或DI(Dependency Injection) IOC控制权反转 原来：我的Service需要调用DAO，Service就需要创建DAO Spring:Spring发现你Service依赖于dao,就给你注入. 核心原理：就是配
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值