Spring框架的AOP(IOC和DI)

最新推荐文章于 2023-12-02 12:46:56 发布
最新推荐文章于 2023-12-02 12:46:56 发布
阅读量108 收藏
点赞数
文章标签： spring java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangzhigang0926/article/details/129925811
版权
1.什么是spring框架？
spring是一个开放源代码的设计层面框架,它解决的是业务逻辑层和其他各层的松耦合问题,是一个分层的javaEE一站式轻量级开 源框
架.
2.spring的作用?
方便解耦,简化开发，AOP编程支持，声明式事务支持，集成Junit更加方便的进行分层测试，方便集成各种优秀框架.
3.什么是IOC？
控制反转,把创建对象的权利交给spring
4.什么是DI?
属性的依赖注入，spring在通过IOC创建对象的时候,如果对象还有属性,就一并给赋值进去DI是在IOC的基础上进行对象的属性 注入
5.依赖注入的三种实现方式？
构造器注入，Setter方法注入，接口注入

5.什么是AOP：在软件业,AOP为Aspect Oriented Programming的缩写,意味:面向切面编程.通过预编译方式和运行期动态代理实现程序功能的统 一维护的一种技术,AOP是OOP的延续.将一些共性的内容进行抽取，在需要用到的地方，以动态代理的方式进行插入.在不修 改源 码的基础上，还能对源码进行前后增强。

6.Spring支持的事务管理类型?

a、编程式事务管理：这意味你通过编程的方式管理事务，给你带来极大的灵活性，但是难维护。 b、声明式事务管理：这意味着你可以将业务代码和事务管理分离，你只需用注解和XML配置来管理事务。

一，Spring注解

1.创建项目封装jar包，创建包类，如下：

 2.各层代码

advice层（增强类）

package com.wang.advice;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class Loger {
    @Before("execution(* *..BookServiceImpl.*(..))")
    public void check(){
        System.out.println("前置通知/增强 ，执行系统的权限验证");
    }
    @AfterReturning("execution(* *..BookServiceImpl.*(..))")
    public void logPrint(){
        System.out.println("后置");
    }
    @AfterThrowing("execution(* *..BookServiceImpl.*(..))")
    public void exception(){
        System.out.println("异常");
    }
    @After("execution(* *..BookServiceImpl.*(..))")
    public void distory(){
        System.out.println("最终");
    }
}

sevice层

//接口
package com.wang.service;

public interface BookService {
    int save(int n);
    int qian();
    int hou();
    void rap();
}
//实现类
package com.wang.service.impl;

import com.wang.service.BookService;
import org.springframework.stereotype.Component;

@Component
public class BookServiceImpl implements BookService {
    @Override
    public int save(int n) {
        System.out.println("save");
        return 6;
    }
    @Override
    public int qian() {
        return 6;
    }

    @Override
    public int hou() {
        return 7;
    }

    @Override
    public void rap() {
        System.out.println("rap");
    }
}

spring层（spring配置文件）

<?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"
       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.xsd">
<!--扫描component及同名注解-->
     <context:component-scan base-package="com.wang"/>
<!--开启AOP注解支持-->
    <aop:aspectj-autoproxy/>

servlet层

package com.wang.servlet;

import com.wang.service.BookService;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test01 {
    @Test
    public void add(){
        //获取ClassPathXmlApplicationContext对象
        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");
        //通过ClassPathXmlApplicationContext对象调取getBean
        BookService bookService=context.getBean(BookService.class);
        bookService.save(6);
    }

}

二，Spring纯注解

1.创建的项目包名类名 如下：

 2.各类中的代码

advice层

package com.wang.advice;

import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class Loger {
    @Before("execution(* *..BookServiceImpl.*(..))")
    public void befor() {
        System.out.println("前置通知");
    }

    @AfterReturning("execution(* *..BookServiceImpl.*(..))")
    public void houzhi() {
        System.out.println("后置通知");
    }

    @AfterThrowing("execution(* *..BookServiceImpl.*(..))")
    public void yichang() {
        System.out.println("异常通知");
    }

    @After("execution(* *..BookServiceImpl.*(..))")
    public void zuizhong() {
        System.out.println("最终通知");
    }
}

config层

package com.wang.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration//表示该类是配置类
@ComponentScan("com.wang")
@EnableAspectJAutoProxy
public class SpringConfig {
}

service层

//接口
package com.wang.service;

public interface BookService {
    void select();
    void update();
    void del();
    void add();
}
//实现类
package com.wang.service.impl;

import com.wang.service.BookService;
import org.springframework.stereotype.Component;

@Component
public class BookServiceImpl implements BookService {

    @Override
    public void select() {
        System.out.println("查询...select");
    }

    @Override
    public void update() {
        System.out.println("修改...update");
    }

    @Override
    public void del() {
        System.out.println("删除...del");
    }

    @Override
    public void add() {
        System.out.println("增加...add");
    }
}

servlet层

package com.wang.servlet;

import com.wang.config.SpringConfig;
import com.wang.service.BookService;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Test01 {
    @Test
    public void add(){
        //加载配置类，获得ioc的容器
        AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(SpringConfig.class);
        BookService bookService=context.getBean(BookService.class);
        bookService.add();
    }
}

运行效果

 三，spring环绕通知

1.创建的项目，包名类名如下

 2.各类中的代码

advice层

package com.wang.advice;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class Loger {
public Object around(ProceedingJoinPoint pjp){
        try{
            //前置增强
            System.out.println("环绕通知----前置增强");
            //通知ProceedingJoinPoint 完成代理对象的方法调用
            Object result=null;//定义返回值变量
            Object[] args=pjp.getArgs();//获取参数列表
            result=pjp.proceed(args);//核心类方法的执行

            //后置增强
            System.out.println("环绕通知----后置增强");
            return result;
        } catch (Throwable e) {
            //异常
            System.out.println("环绕通知----异常增强");
            throw new RuntimeException(e);
        }finally {
            //最终
            System.out.println("环绕通知----最终增强");
        }
    }

}

service层

//接口
package com.wang.service;

public interface BookService {
    int save(int n);
    int qian();
    int hou();
    void rap();
}
//实现类
package com.wang.service.impl;

import com.wang.service.BookService;
import org.springframework.stereotype.Component;

@Component
public class BookServiceImpl implements BookService {
    @Override
    public int save(int n) {
        System.out.println("save");
        return 6;
    }
    @Override
    public int qian() {
        return 6;
    }

    @Override
    public int hou() {
        return 7;
    }

    @Override
    public void rap() {
        System.out.println("rap");
    }
}

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"
       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.xsd">
    <!--1.把所有类的对象交给IOC容器进行管理-->
    <bean id="loger" class="com.wang.advice.Loger"/>
    <bean id="bookService" class="com.wang.service.impl.BookServiceImpl"/>
<!--    2.AOP的配置：让增强类 的 哪个方法  动态进行何种增强   核心类 的 哪个方法-->
    <aop:config>
        <aop:aspect id="log" ref="loger">
            <aop:around method="around" pointcut="execution(* *..BookServiceImpl.*(..))"/>
        </aop:aspect>
    </aop:config>

    </beans>

servlet层

package com.wang.servlet;

import com.wang.service.BookService;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test01 {
    @Test
    public void add(){
        //获取ClassPathXmlApplicationContext对象
        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");
        //通过ClassPathXmlApplicationContext对象调取getBean
        BookService bookService=context.getBean(BookService.class);
        bookService.save(6);
    }

}

运行效果

 

wangzhigang0926
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
springioc和spring aop
09-05
控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找...
spring AOP的使用方法
Crime11的博客
03-23 1537
Spring AOP是一个基于Java的AOP框架，它是Spring框架的一部分。Spring AOP支持的通知类型包括前置通知、后置通知、环绕通知、引发异常通知和最终通知。可以使用Spring AOP来定义切面、切入点和通知，并配置Spring AOP，在执行前和执行后输出一些消息。在上面的例子中，我们定义了一个LoggingAspect类，它包含了两个通知方法：logBefore()和logAfter()。现在我们已经定义了一个切面类，并且配置了Spring AOP，我们可以测试它是否工作。
Spring中实现AOP的三种方式
七一
08-16 1228
1、什么是AOP AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 2、AOP在Spring中的作用 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无
超详细讲解Spring-IOC、DI、AOP概念并通俗解释
最新发布
qq_46248151的博客
12-02 276
IOC 让我们不再主动管理对象和依赖关系，而是交给容器去做；DI 让我们不再主动获取依赖的对象，而是由容器来注入；AOP 让我们不再重复写一些共同的功能代码，而是把它们整合在一起来管理。这些概念的引入，使得程序的开发更加灵活、易于扩展和维护。
Spring（IOC、DI、AOP、注解）
乌昂先生的博客
11-19 295
工厂方法模式，
Spring中AOP技术
车车的博客
11-06 210
AOP(Aspect Oriented Programing)面向切面编程 通过预编译方式或者运行时动态代理方式实现程序功能的统一维护，可以理解为扩展功能而不用修改源代码 Java程序的执行流 程序运行的过程就是方法调用的过程。我们按照方法执行的顺序，将方法调用排成一串，这样就构成了Java程序流。 将上述的线程栈里的方法调用按照执行流排列，会有如下类似的图 基于时间序列，我们可以将方法调用排成一条线。而每个方法调用则可以看成Java执行流中的一个节点。这个节点在AOP的术语中，被称为Jo
关于spring的AOP ,IOC,DI的理解
09-11
帮助初学者理解spring框架,有助于提高代码能力java.sql.SQLException: Duplicate entry '2' for key 'PRIMARY' Query: insert into transaction values(?,?,?,?,?) Parameters: [2, 6212999999999, 转出, 6000000, ...
spring的IoC和DI详解
08-28
主要介绍了spring的IoC和DI详解，还是挺不错的，这里分享给加，需要的朋友可以参考下。
Spring IOC DI AOP 事务)
12-14
目录IOC（控制反转）DI（依赖注入）AOP（面向切面编程）Spring事务事务传播特性脏读，不可重复读，幻读事务隔离级别不喜勿喷 如有雷同请联系本人！！ IOC（控制反转） IOC是一种设计思想，而不是什么技术 传统方法...
简单理解Spring之IOC和AOP及代码示例
08-28
主要介绍了简单理解Spring之IOC和AOP及代码示例，具有一定参考价值，需要的朋友可以了解下。
理解Spring的AOP和Ioc/DI就这么简单
热门推荐
浮晓悠羡
05-26 3万+
本文以通俗易懂的例子阐述了什么是AOP、Ioc、DI，相信读者看了之后会很容易明白 AOP —— Asepct-Orentid-Programming，面向切面编程 那么我们该怎么理解AOP呢？我们可以通过OOP —— 面向对象编程来进行比较分析 相信大家对于OOP的理解不难，就以人（people）来说，我们就可以把它看做一类对象，people有身高、体重、年龄等属性，也有跑步、吃饭、睡觉、娱乐等行为，把这些属于people的属性和行为封装在people类中，然后以统一调
Spring入门——DI与AOP简介
weixin_44271683的博客
03-12 370
前言 在诞生之初，创建Spring的主要目的是用赖替代更加重量级的企业级java技术，尤其是EJB。相对于EJB来说，Spring提供了更加轻量级和简单的编程模型。他增强了简单老式java对象POJO的功能，使其具备了之前只有EJB和其他企业级Java规范才具有的功能。 简化java开发 为了降低java开发的复杂性，Spring采取了以下4中关键策略： 基于POJO的轻量级和最小侵入性编程； ...
Spring 的 AOP 的支持
weixin_33749131的博客
12-18 123
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring IOC/DI和AOP
程序小白进阶之路
05-17 5992
一、分享Iteye的开涛对Ioc的精彩讲解 首先要分享的是Iteye的开涛这位技术牛人对Spring框架的IOC的理解，写得非常通俗易懂，以下内容全部来自原文，原文地址：http://jinnianshilongnian.iteye.com/blog/1413846 1.1、IoC是什么 　　Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。在Jav...
Spring框架核心介绍：DI和AOP
风云海滩的博客
09-02 1084
Spring一个开源框架，最初是为了解决企业级应用开发的复杂性而创建的，使用Spring可以让简单的JavaBean实现之前只有EJB才能完成的实情，但现在的Spring不仅仅局限于这些功能。 为降低Java开发的复杂性Spring采用的策略 基于POJO的轻量级和最小侵入性编程 通过依赖注入和面向接口实现松耦合 基于切面和惯例进行声明式编程 通过切面和模块减少样板式代码 什么是依赖注入（DI）依赖
Spring的IOC,DI和AOP
不羁朔风的博客
11-06 7250
spring的优点 ①IOC和DI降低了组件之间的耦合性 ，让程序员更专注于业务逻辑 ②容器提供了众多的辅助类，能加快应用的开发 ③spring对于主流的应用框架提供了集成支持，如hibernate，mybatis，Struts等 ④spring属于低侵入式设计，代码的污染极低 ⑤容器提供了AOP技术，利用它可以方便的实现权限拦截等功能 ⑥创建对象默认是单例的，不需要再使用单例模式进行...
Spring中的AOP（二）——AOP基本概念和Spring对AOP的支持
weixin_34174322的博客
03-17 134
为什么80%的码农都做不了架构师？>>> ...
Spring的DI和AOP
长河渐落晓星沉
04-09 381
基于POJO的轻量级和最小入侵性编程 POJO–简单的java对象。 释义： Spring不会强迫你继承他的类或者实现它的接口，最坏的情况就是使用Spring的注解； 使用非侵入性编程这样我们不论是在Spring应用还是非Spring应用中都能够发挥同样的作用； Spring通过DI来帮助应用对象实现松耦合； 两个简单的例子比较： 而通过DI,在对象创建的时候，第三方的插件进...
Spring aop--几种不同的使用方式
xuyunti的博客
01-24 239
最近听老师讲关于AOP关于容器的课，突然觉得之前对aop的理解都不是很到位，先不说理解就是应用都很少，最近也写了几篇关于AOP的博客，都是一些简单的demo，今天在这里再说一下关于Spring AOP的几种实现方式。         我们经常会用到的有如下几种         1、基于代理的AOP         2、纯简单java对象切面         3、@Aspect注解形式的 ...
spring diIOC 和aop
07-27
总结来说，DI和IOC是Spring框架中用于管理对象依赖关系的机制，而AOP是用于实现横切关注点的机制。它们都是Spring框架中重要的特性，可以帮助开发者更好地组织和管理代码。 #### 引用[.reference_title] - *1* ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值