如何一文快速认识 Spring 框架（AOP 编程）

最新推荐文章于 2021-12-12 14:22:22 发布
最新推荐文章于 2021-12-12 14:22:22 发布
阅读量680 收藏 2
点赞数
分类专栏： # Spring框架 文章标签： aop java spring 软件框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fujuacm/article/details/105567440
版权

文章目录

前文： 如何一文快速认识 Spring 框架（IoC控制反转）

1、AOP 概述

1.1、什么是 AOP

AOP：全称是 Aspect Oriented Programming 即：面向切面编程。
在这里插入图片描述
  简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。

1.2、AOP 的作用及优势

作用：
  在程序运行期间，不修改源码对已有方法进行增强。
优势：
  减少重复代码
  提高开发效率
  维护方便

2、Spring 中的 AOP 细节

2.1、AOP 相关术语

Joinpoint( 连接点):
  所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。
Pointcut( 切入点):
  所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。
Advice( 通知/ 增强):
  所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。
Introduction( 引介):
  引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field。
Target( 目标对象):
  代理的目标对象。
Weaving( 织入):
  是指把增强应用到目标对象来创建新的代理对象的过程。spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。
Proxy （代理）:
  一个类被 AOP 织入增强后，就产生一个结果代理类。
Aspect( 切面):
  是切入点和通知（引介）的结合。

2.2、学习 spring 中的 AOP 要明确的事

a 、开发阶段（我们做的）
  编写核心业务代码（开发主线）：大部分程序员来做，要求熟悉业务需求。
  把公用代码抽取出来，制作成通知。（开发阶段最后再做）：AOP 编程人员来做。
  在配置文件中，声明切入点与通知间的关系，即切面。：AOP 编程人员来做。
b 、运行阶段（Spring 框架完成的）
  Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。

2.3、关于代理的选择

动态代理常用的有两种方式：
1、基于接口的动态代理
  提供者：JDK 官方的 Proxy 类。
  要求：被代理类最少实现一个接口。
2、基于子类的动态代理
  提供者：第三方的 CGLib，如果报 asmxxxx 异常，需要导入 asm.jar。
  要求：被代理类不能用 final 修饰的类（最终类）。
在 spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

3、基于 XML 的 AOP 配置

3.1、环境搭建

3.1.1、第一步：准备代码

包含账户实体类，操作账户的业务层和持久层代码

3.1.2、第二步：拷贝必备的 jar 包到工程的 lib

在这里插入图片描述
或者添加如下依赖坐标：

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.1.RELEASE</version>
       </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>RELEASE</version>
        </dependency>
        <!-- 解析切入点表达式和切面 -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.7</version>
        </dependency>
    </dependencies>

3.1.3、第三步：创建 spring 的配置文件并导入约束

此处要增加导入 aop 的约束

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

3.1.4、第四步：配置 spring 的 ioc

<!-- 配置 service -->
<bean id="accountService" class="per.cjh.service.impl.AccountServiceImpl">
	<property name="accountDao" ref="accountDao"></property>
</bean>
<!-- 配置 dao -->
<bean id="accountDao" class="per.cjh.dao.impl.AccountDaoImpl">
	<property name="dbAssit" ref="dbAssit"></property>
</bean>
<!-- 配置数据库操作对象 -->
<bean id="dbAssit" class="per.cjh.dbassit.DBAssit">
	<property name="dataSource" ref="dataSource"></property>
	<!-- 指定 connection 和线程绑定 -->
	<property name="useCurrentConnection" value="true"></property>
</bean>
<!-- 配置数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
	<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
	<property name="jdbcUrl" value="jdbc:mysql:///springDB"></property>
	<property name="user" value="root"></property>
	<property name="password" value="root"></property>
</bean>

3.1.5、第五步：抽取公共代码制作成通知

/**
* 事务控制类
*/
public class TransactionManager {
	//定义一个 DBAssit
	private DBAssit dbAssit ;
	public void setDbAssit(DBAssit dbAssit) {
		this.dbAssit = dbAssit;
	}
	//开启事务
	public void beginTransaction() {
		try {
			dbAssit.getCurrentConnection().setAutoCommit(false);
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	//提交事务
	public void commit() {
		try {
			dbAssit.getCurrentConnection().commit();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	//回滚事务
	public void rollback() {
		try {
			dbAssit.getCurrentConnection().rollback();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	//释放资源
	public void release() {
		try {
			dbAssit.releaseConnection();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

3.2、配置 AOP 的步骤

3.2.1、第一步：把通知类用 bean 标签配置起来

<!-- 配置通知，即将通知类交给 IoC 容器管理。用于配置界面时 直接引用该通知 bean -->
<bean id="txManager" class="per.cjh.utils.TransactionManager">
	<property name="dbAssit" ref="dbAssit"></property>
</bean>

3.2.2、第二步：使用 aop:config 声明 aop 配置

aop:config:
  作用：用于声明开始 aop 的配置

<aop:config>
	<!-- 配置的代码都写在此处 -->
</aop:config>

3.2.3、第三步：使用 aop:aspect 配置切面

aop:aspect:
作用：
  用于配置切面。
属性：
  id：给切面提供一个唯一标识。
  ref：引用配置好的通知类 bean 的 id。

<aop:aspect id="txAdvice" ref="txManager">
	<!--配置通知的类型要写在此处-->
</aop:aspect>

3.2.4、第四步：使用 aop:pointcut 配置切入点表达式

  此标签写在 aop:aspect 标签内部只能当前切面使用。写在 aop:aspect 外面 aop:config 内部，则可以在 aop:config 配置的多个切面 aspect 中共同引用。并且此时该标签得位于引用切面的前行。
aop:pointcut ：
作用：
  用于配置切入点表达式。就是指定对哪些类的哪些方法进行增强。
属性：
  expression：用于定义切入点表达式。
  id：用于给切入点表达式提供一个唯一标识。
切入点表达式语法 和 通用化切入点表达式 详看 3.3、切入点表达式说明
如下为完整的切入点表达式写法：

<aop:pointcut expression="execution(public void per.cjh.service.impl.AccountServiceImpl.transfer(java.lang.String, java.lang.String, java.lang.Float))" id="pt1"/>

3.2.5、第 五 步：在切面内部使用 aop:xxx 配置对应的通知类型

1、aop:before
作用：
  用于配置前置通知。指定增强的方法在切入点方法之前执行
属性：
  method:用于指定通知类中的增强方法名称
  pointcut-ref：用于指定切入点的表达式的引用
  poinitcut：用于指定切入点表达式
执行时间点：
  切入点方法执行之前执行

<aop:before method="beginTransaction" pointcut-ref="pt1"/>

2、aop:after-returning
作用：
  用于配置后置通知
属性：
  method ：指定通知中方法的名称
  pointct ：定义切入点表达式
  pointcut-ref ：指定切入点表达式的引用
执行时间点：
  切入点方法正常执行之后。它和异常通知只能有一个执行

<aop:after-returning method="commit" pointcut-ref="pt1"/>

3、aop:after-throwing
作用：
  用于配置异常通知
属性：
  method ：指定通知中方法的名称
  pointct ：定义切入点表达式
  pointcut-ref ：指定切入点表达式的引用
执行时间点：
  切入点方法执行产生异常后执行。它和后置通知只能执行一个

<aop:after-throwing method="rollback" pointcut-ref="pt1"/>

4、aop:after
作用：
  用于配置最终通知
属性：
  method ：指定通知中方法的名称
  pointct ：定义切入点表达式
  pointcut-ref ：指定切入点表达式的引用
执行时间点：
  无论切入点方法执行时是否有异常，它都会在其后面执行

<aop:after method="release" pointcut-ref="pt1"/>

3.3、切入点表达式说明

execution:匹配某类方法的执行(常用)
execution(表达式)
  表达式语法：execution([修饰符] 返回值类型 包名.类名.方法名(参数))
如下表达式：public void per.cjh.service.impl.AccountServiceImpl.saveAccount(per.cjh.domain.Account)

  • 访问修饰符可以省略
  • 返回值可以使用*号，表示任意返回值
  • 包名可以使用号，表示任意包，但是有几级包，需要写几个
  • 使用…来表示当前包，及其子包
  • 类名可以使用*号，表示任意类
  • 方法名可以使用*号，表示任意方法
  • 参数列表可以使用*，表示参数可以是任意数据类型，但是必须有参数
  • 参数列表可以使用…表示有无参数均可，有参数可以是任意类型
  • 全通配方式：
	* *..*.*(..)

注：(常用)
  通常情况下，我们都是对业务层的方法进行增强，所以切入点表达式都是切到业务层实现类。

execution(* per.cjh.service.impl.*.*(..))

3.4、环绕通知

配置方式:

<aop:config>
	<aop:pointcut  expression="execution(*  per.cjh.service.impl.*.*(..))" id="pt1"/>
	<aop:aspect id="txAdvice" ref="txManager">
		<!-- 配置环绕通知 -->
		<aop:around method="transactionAround" pointcut-ref="pt1"/>
	</aop:aspect>
</aop:config>

aop:around：
作用：
  用于配置环绕通知
属性：
  method：指定通知中方法的名称
  pointct：定义切入点表达式
  pointcut-ref：指定切入点表达式的引用
说明：
  它是 spring 框架为我们提供的一种可以在代码中手动控制增强代码什么时候执行的方式。
注意：
  通常情况下，环绕通知都是独立使用的。当我们配置了环绕通知之后，切入点方法没有执行，而通知方法执行了。我们需要在环绕通知方法内部调用切入点方法。
解决：
  Spring框架提供了一个接口：ProceedingJoinPoint。该接口有一个方法proceed()。调用此方法时相当于明确调用切入点方法。

/**
* 环绕通知
* @param pjp
* spring 框架为我们提供了一个接口：ProceedingJoinPoint，它可以作为环绕通知的方法参数。
* 在环绕通知执行时，spring 框架会为我们提供该接口的实现类对象，我们直接使用就行。
* @return
*/
public Object transactionAround(ProceedingJoinPoint pjp) {
	//定义返回值，是pjp.proceed()切入点方法执行之后获得的返回值
	Object rtValue = null;
	try {
		//前置通知：开启事务
		beginTransaction();
		//获取方法执行所需的参数
		Object[] args = pjp.getArgs();
		//执行切入点方法
		rtValue = pjp.proceed(args);
		//后置通知：提交事务
		commit();
	}catch(Throwable e) { 
		//异常通知：回滚事务
		rollback();
		e.printStackTrace();
	}finally {
		//最终通知：释放资源
		release();
	}
	return rtValue;
}

4、基于注解的 AOP 配置

4.1、环境搭建

4.1.1、第一步：准备必要的代码和 jar 包

必要代码：包含账户实体类，操作账户的业务层和持久层代码
jar包：和基于 XML 的 AOP 配置 jar 包等同

4.1.2、第二步：在配置文件中导入 context 的名称空间

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	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
		http://www.springframework.org/schema/aop
		http://www.springframework.org/schema/aop/spring-aop.xsd
		http://www.springframework.org/schema/context
		http://www.springframework.org/schema/context/spring-context.xsd">
	<!-- 配置数据库操作对象 -->
	<bean id="dbAssit" class="per.cjh.dbassit.DBAssit">
		<property name="dataSource" ref="dataSource"></property>
		<!-- 指定 connection 和线程绑定 -->
		<property name="useCurrentConnection" value="true"></property>
	</bean>
	<!-- 配置数据源 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
		<property name="jdbcUrl" value="jdbc:mysql:///spring_day02"></property>
		<property name="user" value="root"></property>
		<property name="password" value="1234"></property>
	</bean>
</beans>

4.1.2、第三步：把资源使用注解配置

/**
* 账户的业务层实现类
*/
@Service("accountService")
public class AccountServiceImpl implements IAccountService {
	@Autowired
	private IAccountDao accountDao;
}

/**
* 账户的持久层实现类
*/
@Repository("accountDao")
public class AccountDaoImpl implements IAccountDao {
	@Autowired
	private DBAssit dbAssit ;
}

4.1.3、第四步：在配置文件中指定 spring 要扫描的包

<!-- 告知 spring，在创建容器时要扫描的包 -->
<context:component-scan base-package="per.cjh"></context:component-scan>

4.2、配置步骤

4.2.1、第一步：把通知类也使用注解配置

/**
* 事务控制类
*/
@Component("txManager")
public class TransactionManager {
	//定义一个 DBAssit
	@Autowired
	private DBAssit dbAssit ;
}

4.2.2、第二步：在通知类上使用 @Aspect 注解声明为切面

作用：
  把当前类声明为切面类。

/**
* 事务控制类
*/
@Component("txManager")
@Aspect//表明当前类是一个切面类
public class TransactionManager {
	//定义一个 DBAssit
	@Autowired
	private DBAssit dbAssit ;
}

4.2.3、第三步：在增强的方法上使用注解配置通知

1、@Before
作用：
  把当前方法看成是前置通知。
属性：
  value：用于指定切入点表达式，还可以指定切入点表达式的引用。
2、@AfterReturning
作用：
  把当前方法看成是后置通知。
属性：
  value：用于指定切入点表达式，还可以指定切入点表达式的引用
3、@AfterThrowing
作用：
  把当前方法看成是异常通知。
属性：
  value：用于指定切入点表达式，还可以指定切入点表达式的引用
4、@After
作用：
  把当前方法看成是最终通知。
属性：
  value：用于指定切入点表达式，还可以指定切入点表达式的引用

//开启事务
@Before("execution(* per.cjh.service.impl.*.*(..))")
public void beginTransaction() {
	try {
		dbAssit.getCurrentConnection().setAutoCommit(false);
	} catch (SQLException e) {
		e.printStackTrace();
	}
}
//提交事务
@AfterReturning("execution(* per.cjh.service.impl.*.*(..))")
public void commit() {
	try {
		dbAssit.getCurrentConnection().commit();
	} catch (SQLException e) {
		e.printStackTrace();
	}
}
//回滚事务
@AfterThrowing("execution(* per.cjh.service.impl.*.*(..))")
public void rollback() {
	try {
		dbAssit.getCurrentConnection().rollback();
	} catch (SQLException e) {
		e.printStackTrace();
	}
}
//释放资源
@After("execution(* per.cjh.service.impl.*.*(..))")
public void release() {
	try {
		dbAssit.releaseConnection();
	} catch (Exception e) {
		e.printStackTrace();
	}
}

4.2.4、第四步：在 spring 配置文件中开启 spring 对注解 AOP 的支持

<!-- 开启 spring 对注解 AOP 的支持 -->
<aop:aspectj-autoproxy/>

4.3、环绕通知注解配置

@Around
作用：
  把当前方法看成是环绕通知。
属性：
  value：用于指定切入点表达式，还可以指定切入点表达式的引用。

/**
* 环绕通知
* @param pjp
* @return
*/
@Around("execution(* per.cjh.service.impl.*.*(..))")
public Object transactionAround(ProceedingJoinPoint pjp) {
	//定义返回值
	Object rtValue = null;
	try {
		//获取方法执行所需的参数
		Object[] args = pjp.getArgs();
		//前置通知：开启事务
		beginTransaction();
		//执行方法
		rtValue = pjp.proceed(args);
		//后置通知：提交事务
		commit();
	}catch(Throwable e) {
		//异常通知：回滚事务
		rollback();
		e.printStackTrace();
	}finally {
		//最终通知：释放资源
		release();
	}
	return rtValue;
}

4.4、切入点表达式注解

@Pointcut
作用：
  指定切入点表达式
属性：
  value：指定表达式的内容

@Pointcut("execution(* per.cjh.service.impl.*.*(..))")
private void pt1() {}
/**
* 引用方式：
* 环绕通知
* @param pjp
* @return
*/
@Around("pt1()") // 注意：千万别忘了写括号
public Object transactionAround(ProceedingJoinPoint pjp) {
	//定义返回值
	Object rtValue = null;
	try {
		//获取方法执行所需的参数
		Object[] args = pjp.getArgs();
		//前置通知：开启事务
		beginTransaction();
		//执行方法
		rtValue = pjp.proceed(args);
		//后置通知：提交事务
		commit();
	}catch(Throwable e) {
		//异常通知：回滚事务
		rollback();
		e.printStackTrace();
	}finally {
		//最终通知：释放资源
		release();
	}
	return rtValue;
}

4.5、不使用 XML 的配置方式

  创建配置类添加前文 IoC 中所说的两个注解 @Configuration 和 @ComponentScan(basePackages=“per.cjh”) 再添加新增的开启对 AOP 支持的注解 @EnableAspectJAutoProxy

@Configuration
@ComponentScan(basePackages="per.cjh")
@EnableAspectJAutoProxy
public class SpringConfiguration {
}

5、前文：Spring 的 IoC 编程

如何一文快速认识 Spring 框架（IoC控制反转）

6、后文：Spring 整合 Junit 单元测试

如何使用 Spring 整合 junit 单元测试

cjh-Java
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
如何能理解 Spring 框架的思想？
CSDN大数据
05-05 288
01Spring 简述1.1 什么是 Spring ?Spring 是一个轻量级的开源的 JavaEE 框架，由作者 Rod Johnson 创建，兴起于 2003 年。...
快速熟悉spring框架
文生同学
02-21 432
一，首先来看一下今天所学内容 Spring 框架简介及官方压缩包目录介绍 Spring 环境搭建 IoC 详解 Spring 创建 Bean 的三种方式(包含两种工厂方式) scope 属性讲解(包含单例设计模式) DI 详解 Spring 中几种注入方式 利用 Spring DI 实现生成 SqlSessionFactory 对象 一.Spring 框架简介及官方压缩包目录 介绍...
如何一文快速认识 Spring 框架（IoC控制反转）
cjh的博客
04-17 1184
文章目录1、 Spring 概述1.1、Spring 是什么1.2、Spring 的发展历程1.3、Spring 的优势1.3.1、方便解耦，简化开发1.3.2、AOP 编程的支持1.3.3、声明式事务的支持（配置实现事务控制）1.3.4、方便程序的测试（整合 junit）1.3.5、方便集成各种优秀框架（SSM 整合）1.3.6、降低 JavaEE API 的使用难度1.3.7、Spring ...
spring框架实现aop编程 使用注解方式自动扫描生成代理实现编程并且测试
_纳川
10-18 551
spring不仅可以通过使用xml标签的方式实现，生成切面，还可以通过注解方式声明切面。 基于注解方式声明切面,实现AOP编程 采用注解方式实现(Annotation)步骤: 先在beans.xml文件中引用aop schema，然后启动代理自动生成的扫描配置 拦截器进行注解开发 拦截器和service都要在beans.xml文件中配置 xml文件注解详细表： @Befor...
Spring框架实现AOP的两种实现方式
achu19的博客
06-02 519
Spring AOP 概念 面向切面编程，扩展功能不需修改源代码 AOP采用横向抽取机制，取代了纵向抽取机制 在运行时，动态地将代码切入到类的指定方法、指定位置上的编程思想 AOP和OOP的关系 AOP面向切面编程，而OOP面向对象编程 AOP是对OOP的一种补充，而不是对立关系 AOP的演变 从纵向抽取机制–>横向抽取机制 AOP底层使用动态代理方式实现 第一种情况：有接口，使用JDK动态代理方式创建接口实现类的代理对象 第二种情况：没有接口，使用cglib创建类的子类代理对象 总结 函数
Spring框架,AOP,Spring整合Mybatis
最新发布
01-13
Spring框架是Java开发中最广泛应用的轻量级框架之一，它提供了强大的依赖注入（DI）以及面向切面编程（AOP）功能。AOP是Spring框架的核心特性，它允许程序员将关注点分离，使得业务逻辑与系统服务如日志、事务管理等...
使用Spring框架实现AOP切面编程.zip
03-09
本资源通过一个Category和Publisher表的实例，使用Spring框架实现AOP切面编程，其中实现了增删改查的功能，通过事物(tx)管理器、扫描业务逻辑、声明式事务达到切面编程效果。代码中有很详细的备注，适合新手入门
Spring-AOP编程.docx
11-18
Spring AOP 编程 Spring AOP（Aspect-Oriented Programming，面向切面编程）是一种编程技术，它可以将横切关注点从核心业务逻辑中分离出来，提高系统的可维护性、可扩展性和灵活性。AOP 是 OOP 的补充和完善，可以...
Spring框架实现AOP添加日志记录功能过程详解
08-25
Spring框架实现AOP添加日志记录功能过程详解 本文主要介绍了使用Spring框架实现AOP添加日志记录功能的过程详解。通过示例代码，详细介绍了如何在业务方法的前面和后面添加日志记录功能。 首先，需要了解什么是AOP...
Spring框架-AOP和声明式事务
11-13
Spring框架-AOP和声明式事务
Swing串行化
yinbodotcc的专栏
12-22 765
     大多数Swing方法都不是线程安全的，所以你需要串行化的执行调用；但是如果同时调用了这些方法，就会出现很混乱的结果。   但是 大多数情况下都是没有问题的，因为Swing的方法并不会立即被执行（比如repaint函数），而是会到一个队列中去排队，然后由一个特殊的线程（叫做事件分派线程）来监控这些请求，使得它们能够串行执行
Spring中的AOP使用
QQ3156304857的博客
12-12 1376
Spring中的AOP使用 1.AOP术语。 2.AOP使用。
Spring AOP 的实现方式（以日志管理为例）
热门推荐
一个普本码农奋斗史
10-08 4万+
在学习Spring框架的历程中，最重要的是要理解spring的IOC和AOP了，不但要学会怎么用，最好是知道它是怎么实现的，通过这个国庆假期，好好地过了一下spring的AOP的皮毛，故记录一下学习心得。 一、为什么需要AOP 假如我们应用中有n个业务逻辑组件，每个业务逻辑组件又有m个方法，那现在我们的应用就一共包含了n*m个方法，我会抱怨方法太多。。。现在，我有这样一个需求，每个方法都增加一
【Spring框架学习】：初识Spring框架
life is wonderful
12-23 6607
软件框架        框架（Framework）是整个或部分系统的可重用设计，表现为一组抽象构件及构件实例间交互的方法；另一种定 义认为，框架是可被应用开发者定制的应用骨架。前者是从应用方面而后者是从目的方面给出的定义。框架就是制定 一套规范或者规则(思想)，程序员在该规范或者规则下工作。或者说就是使用别人搭好的舞台，你来做表演。        软件框架，通常指的是为了实现某个业界标准或
如何识别java系统采用了spring框架
qq_37495639的博客
07-16 2516
如何识别java系统采用了spring框架 看看***web.xml***里没有类似于这种的配置： <context-param> <param-name>contextConfigLocation</param-name> <param-value>classpath*:applicationContext*.xml</param-value> </context-param> ...
什么是spring，谈谈你对spring的理解5
清缘幽梦
12-19 3万+
1.首先Spring是一个开源的框架，Spring为简化企业级应用开发而生，使用Spring可以使简单的JavaBean实现以前只有EJB才能实现的功能。Spring是一个IOC和AOP容器框架。 在java开发领域，Spring相对于EJB来说是一种轻量级的，非侵入性的Java开发框架。 Spring主要核心是： (1).控制反转(IOC)：以前传统的java开发模式中，当需要一个
Spring-aop实现切面的四种方式 上篇
Seven__________7的博客
11-08 1万+
Spring实现AOP的4种方式     先了解AOP的相关术语: 1.通知(Advice): 通知定义了切面是什么以及何时使用。描述了切面要完成的工作和何时需要执行这个工作。 2.连接点(Joinpoint): 程序能够应用通知的一 个“时机”，这些“时机”就是连接点，例如方法被调用时、异常被抛出时等等。 3.切入点(Pointcut) 通知定义了切面要发生的“故事”和时间，那么
简单认识Spring框架
weixin_45747080的博客
04-07 422
简单认识Spring框架 Spring框架是类似Mybatis的框架，都是采用XML映射文件，后面会将Spring和Mybatis结合使用，会更高效。 这一节课不需要连接数据库使用 1、新建Maven项目：eclipse——文件——新建——其他——Maven Project 2、新建src/main/resources资源文件夹 3、修改pom.xml文件 <properties> ...
spring aop快速使用与详解
qq_32851561的博客
03-02 2946
说明：若想直接参考如何开发，可直接参考第六点的第8条学习思路一、aop介绍AOP Aspect Oriented Programing 面向切面编程AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码Spring AOP使用纯Java实现，不需要专门的编译过程和类加载器，在运行期通过代理方式向目标类织入增强代码使用aop常见应用：性能监控、事务管理、日志记录、缓存图示：二、AspectJ   ...
Spring框架核心技术：IoC容器与AOP编程
核心技术部分 中英双语版 第一部分.pdf”主要涵盖了Spring框架中的核心技术，包括控制反转（IoC）容器、事件处理、资源管理、国际化（i18n）、验证、数据绑定、类型转换、表达式语言（SpEL）以及面向切面编程（AOP）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值