Spring之AOP（面向切面编程）

最新推荐文章于 2024-01-31 16:51:04 发布
最新推荐文章于 2024-01-31 16:51:04 发布
阅读量355 收藏
点赞数
文章标签： aop 编程 代理 java Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_38110604/article/details/78450713
版权

一、概念:

         Aop编程:

                   关注点代码与业务代码分离!(jdk/cglib代理)

         关注点:

                   重复执行的代码, 也叫关注点代码!

public void add(User user) { 
		Session session = null; 
		Transaction trans = null; 
		try { 
			session = HibernateSessionFactoryUtils.getSession();   【关注点代码】
			trans = session.beginTransaction();                    【关注点代码】
			 
			session.save(user);     // 业务代码
			 
			trans.commit();                                        【关注点代码】
		} catch (Exception e) { 
			e.printStackTrace(); 
			if(trans != null){ 
				trans.rollback(); 
			} 
		} finally{ 
			HibernateSessionFactoryUtils.closeSession(session); 
		} 
   }

              切面:

                   关注点代码形成的类,就叫做切面

                   SpringAop编程,也叫面向切面编程!

                   Aop: Aspect Object Programming 面向切面编程!     

    

                   哪些是切面?:事务、权限控制、日志…


         切入点表达式:

                   拦截指定方法,给给指定方法所在的类,生成代理对象!

                   Spring在初始化容器的时候,会根据切入点表达式的规则,会符合拦截规则的方法所在的类生成代理对象!


二、使用Aop注解方式开发步骤:

1. 引入Aop相关jar文件

     (aspectj是在spring之前,面向切面开发的公用组件)

aopalliance.jar              【spring-framework-2.5.6\lib\aopalliance】

aspectjrt.jar                 【spring-framework-2.5.6\lib\aspectj】

aspectjweaver.jar            【spring-framework-2.5.6\lib\aspectj】

spring-aop-3.2.5.RELEASE.jar  【Spring3.2源码】

2.引入Aop名称空间

<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">
	
	<!-- 开启注解扫描 -->
	<context:component-scan base-package="cn.itcast.e_aop_anno"></context:component-scan>
	<!-- 开启aop注解 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
	
</beans>

3. 开启Aop注解

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

4. 使用Aop相关注解

@Aspect        指定一个类为切面类

                                (切面类也需要实例化)

                                (切面类中的方法，也叫做通知)

@Before           前置通知  【在执行目标对象方法之前执行】

@After            后置通知  【在执行目标对象方法之后执行】

@AfterReturning   返回后通知 【在执行目标对象方法结束后执行， 出现异常不执行】

@AfterThrowing    异常通知  【在执行目标对象方法出现异常时候执行】

@Around           环绕通知  【环绕目标方法执行】

@Pointcut         定义一个切入点表达式变量  (后面使用这个切入点表达式的时候,直接引用方法名即可!)

如:

public class TransactionAop {
	
	// 定义一个切入点表达式变量  （后面使用这个切入点表达式的时候，直接引用方法名即可）
	@Pointcut("execution(* spring_ioc.g_aop_anno.UserDao.*(..))")
	public void pointcut_(){
	}

	//【前置通知】
	// 在执行业务方法，之前执行
	@Before("pointcut_()")
	public void beginTransaction() {
		System.out.println("[前置通知]  开启事务..");
	}

Spring生成代理对象的过程？

            1. 创建容器对象的时候,根据"切入点表达式"拦截的类,生成代理对象。

            2. 如果目标对象有实现接口,使用jdk代理！

            3. 如果目标对象没有实现接口,使用cglib代理！

            4. 从容器获取代理后的对象。

            5. 执行代理对象的方法,在运行时期动态植入"切面"类中的"通知"!


四、使用AopXML方式开发步骤:

         1.引入Aop 相关jar文件

         2. bean.xml  引入Aop名称空间

         3. 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: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">
	<!-- UserDao实例加入Spring的IOC容器 -->
	<bean id = "userDao" class = "spring_ioc.h_aop_xml.UserDao"></bean>
	
	<!-- 切面类实例加入容器 -->
	<bean id = "transactionAop" class = "spring_ioc.h_aop_xml.TransactionAop"></bean>
	
	<!-- OrderDao实例加入容器 -->
	<bean id = "orderDao" class = "spring_ioc.h_aop_xml.OrderDao"></bean>
	
	<!-- AOP的相关配置 -->
	<aop:config>
		<!-- 切入点表达式的定义 -->
		<aop:pointcut expression="execution(* spring_ioc.h_aop_xml.UserDao.*(..))" id="pt"/>
	
		<!-- 切面配置 -->
		<aop:aspect ref = "transactionAop">
			<!-- 环绕通知配置 -->
			<aop:around method="arroud" pointcut-ref = "pt"/>
			
			<!-- 前置通知的配置:在目标方法之前执行 -->
			<aop:before method="beginTransaction" pointcut-ref = "pt"/>
			
			<!-- 后置通知的配置:在目标方法之后执行 -->
			<aop:after method="commit" pointcut-ref = "pt"/>
			
			<!-- 返回后通知的配置:在执行目标方法结束后执行,出现异常不会执行 -->
			<aop:after-returning method="afterReturing" pointcut-ref = "pt"/>
			
			<!-- 异常通知的配置:在执行目标方法的时候出现异常执行 -->
			<aop:after-throwing method="afterThrowing" pointcut-ref = "pt"/>
		</aop:aspect>	
		
	</aop:config>
	
</beans>    

五、 切入点表达式语法详解

切入点表达式：

         拦截指定的类,生成代理对象！

expression="execution(* cn.itcast.g_execution.UserDao.save(..))"

execution(

modifiers-pattern?                拦截的方法的访问修饰符(? 表示0或多，可以省略！)

ret-type-pattern                  方法返回类型，必须指定（*）

declaring-type-pattern?           拦截的方法所在的类

name-pattern(param-pattern)       拦截的方法（以及方法的参数列表）

throws-pattern?)   方法声明的异常

总结:拦截，一定要指定到方法！

		<!-- 切入点表达式定义 -->
		
		<!-- 1. 拦截指定的方法(通用)  -->
		<!--<aop:pointcut expression="execution(* cn.itcast.g_execution.UserDao.save(..))" id="pt"/>-->
		
		<!-- 2. 拦截指定的类下所有的方法 -->
		<!--<aop:pointcut expression="execution(* cn.itcast.g_execution.UserDao.*(..))" id="pt"/>-->
		
		<!-- 3. 拦截指定包下所有的类的所有方法 -->
		<!--<aop:pointcut expression="execution(* cn.itcast.g_execution.*.*(..))" id="pt"/>-->
		
		<!-- 3. 拦截指定包，以及其子包下所有类的所有方法 -->
		<!--<aop:pointcut expression="execution(* cn..*.*(..))" id="pt"/>-->
		
		<!-- 5. 拦截所有的public方法 -->
		<!--<aop:pointcut expression="execution(public * *(..))" id="pt"/>-->
		
		<!-- 6. 拦截所有的包含save方法 -->
		<!--<aop:pointcut expression="execution(* *save*(..))" id="pt"/>-->
		
		<!-- 7. 拦截UserDao.save()方法与OrderDao.save() -->
		<!--<aop:pointcut expression="execution(* cn..UserDao.save(..)) || execution(* cn..OrderDao.save(..))" id="pt"/>-->
		<!--<aop:pointcut expression="execution(* cn..UserDao.save(..)) or execution(* cn..OrderDao.save(..))" id="pt"/>-->
		
		<!-- 8. 不拦截UserDao.save()方法 -->
		<!--<aop:pointcut expression="!execution(* cn..UserDao.save(..))" id="pt"/>-->
		<!--<aop:pointcut expression=" not execution(* cn..UserDao.save(..))" id="pt"/>-->
		
		<!-- 9. 拦截UserDao.save()同时拦截OrderDao.save() -->
		<!-- 注意： 这种很少用，一般都是或者的关系即: || 、 or  -->
		<!--<aop:pointcut expression="execution(* cn..UserDao.save(..)) and execution(* cn..OrderDao.save(..))" id="pt"/>-->
		<aop:pointcut expression="execution(* cn..UserDao.save(..)) && execution(* cn..OrderDao.save(..))" id="pt"/>

六、Aop编程之注解方式代码案例:


package spring_ioc.g_aop_anno;
public interface IUserDao {
	void save();
}

package spring_ioc.g_aop_anno;
import org.springframework.stereotype.Repository;
@Repository	// 把对象加入ioc容器
public class UserDao implements IUserDao{
	public void save() {
		System.out.println("保存...");
	}
}

package spring_ioc.g_aop_anno;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

// 重复代码
@Component("aop")
@Aspect      // 指定一个类为切面类
public class TransactionAop {
	
	// 定义一个切入点表达式变量  （后面使用这个切入点表达式的时候，直接引用方法名即可）
	@Pointcut("execution(* spring_ioc.g_aop_anno.UserDao.*(..))")
	public void pointcut_(){
	}

	//【前置通知】
	// 在执行业务方法，之前执行
	@Before("pointcut_()")
	public void beginTransaction() {
		System.out.println("[前置通知]  开启事务..");
	}
	
	//【后置通知】
	// 在执行业务方法，之后执行
	@After("pointcut_()")
	public void commit() {
		System.out.println("[后置通知] 提交事务..");
	}
	
	// 【返回后通知】   在执行目标方法结束后执行, 出现异常不会执行
	@AfterReturning("pointcut_()")
	public void afterReturing(){
		System.out.println("[返回后通知]");
	}
	
	// 【异常通知】   在执行目标方法的时候出现异常执行
	@AfterThrowing("pointcut_()")
	public void afterThrowing(){
		System.out.println("[异常通知]");
	}
	
	// 【环绕通知】 会环绕目标方法执行
	@Around("pointcut_()")
	public void arroud(ProceedingJoinPoint pjp) throws Throwable{
		System.out.println("[环绕前：]");
		pjp.proceed();    			   // 执行目标方法
		System.out.println("[环绕后：]");
	}

}

package spring_ioc.g_aop_anno;
import org.springframework.stereotype.Repository;
@Repository
public class OrderDao {
	public void save(){
		System.out.println("订单已保存!");
	}
}

<?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">
	
	<!-- 开启注解扫描 -->
	<context:component-scan base-package="spring_ioc.g_aop_anno"></context:component-scan>
	<!-- 开启aop注解 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
	
</beans> 

package spring_ioc.g_aop_anno;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
	 private ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml",getClass());
	 // jdk代理(注意:目标类UserDao实现IUserDao接口!)
	@Test
	public void testApp() throws Exception {
		//从Spring的IOC容器中获取对象,使用接口接收！
		IUserDao userDao = (IUserDao)ac.getBean("userDao");
		System.out.println(userDao.getClass());
		userDao.save();
		
		/*//使用接口接收会报错:java.lang.ClassCastException: $Proxy13 cannot be cast to spring_ioc.g_aop_anno.UserDao
		UserDao userDao = (UserDao)ac.getBean("userDao");
		System.out.println(userDao.getClass());
		userDao.save();*/
		
		/*总结:在Spring的AOP编程中,符合切入点表达式的目标类,如果目标类有实现接口,从容器中获取目标对象的时候一定要通过接口接收否则会报错！
		 * 
		 */
	}
	
	
	//cglib代理(注意:目标类UserDao未实现IUserDao接口!)
	@Test
	public void testApp2(){
		UserDao userDao = (UserDao) ac.getBean("userDao");
		System.out.println(userDao.getClass());
		userDao.save();
	}
	
	
	//测试：没有被切入点表达式拦截的类(OrderDao)是不会生成代理对象的！
	@Test
	public void testApp3(){
		OrderDao orderDao = (OrderDao)ac.getBean("orderDao");
		orderDao.save();
	}
}

testApp():

testApp2():(注意:UserDao实现IUserDao要取消,cglib代理目标类不能实现接口！)


testApp3():(切入点表达式未拦截OrderDao类,所以切面类没有起作用,仅仅输出OrderDao中的save()方法！)



七、Aop编程之xml方式代码案例:

package spring_ioc.h_aop_xml;
public interface IUserDao {
	void save();
}

package spring_ioc.h_aop_xml;
public class UserDao implements IUserDao{
	public void save() {
		System.out.println("保存...");
	}
}

package spring_ioc.h_aop_xml;
import org.aspectj.lang.ProceedingJoinPoint;
//切面类
public class TransactionAop {
	public void beginTransaction() {
		System.out.println("[前置通知]  开启事务..");
	}
	
	public void commit() {
		System.out.println("[后置通知] 提交事务..");
	}
	
	public void afterReturing(){
		System.out.println("[返回后通知]");
	}
	
	public void afterThrowing(){
		System.out.println("[异常通知]");
	}
	
	public void arroud(ProceedingJoinPoint pjp) throws Throwable{
		System.out.println("[环绕前：]");
		pjp.proceed();    			   // 执行目标方法
		System.out.println("[环绕后：]");
	}

}


package spring_ioc.h_aop_xml;
public class OrderDao {
	public void save(){
		System.out.println("订单已保存!");
	}
}

<?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">
	<!-- UserDao实例加入Spring的IOC容器 -->
	<bean id = "userDao" class = "spring_ioc.h_aop_xml.UserDao"></bean>
	
	<!-- 切面类实例加入容器 -->
	<bean id = "transactionAop" class = "spring_ioc.h_aop_xml.TransactionAop"></bean>
	
	<!-- OrderDao实例加入容器 -->
	<bean id = "orderDao" class = "spring_ioc.h_aop_xml.OrderDao"></bean>
	
	<!-- AOP的相关配置 -->
	<aop:config>
		<!-- 切入点表达式的定义 -->
		<aop:pointcut expression="execution(* spring_ioc.h_aop_xml.UserDao.*(..))" id="pt"/>
	
		<!-- 切面配置 -->
		<aop:aspect ref = "transactionAop">
			<!-- 环绕通知配置 -->
			<aop:around method="arroud" pointcut-ref = "pt"/>
			
			<!-- 前置通知的配置:在目标方法之前执行 -->
			<aop:before method="beginTransaction" pointcut-ref = "pt"/>
			
			<!-- 后置通知的配置:在目标方法之后执行 -->
			<aop:after method="commit" pointcut-ref = "pt"/>
			
			<!-- 返回后通知的配置:在执行目标方法结束后执行,出现异常不会执行 -->
			<aop:after-returning method="afterReturing" pointcut-ref = "pt"/>
			
			<!-- 异常通知的配置:在执行目标方法的时候出现异常执行 -->
			<aop:after-throwing method="afterThrowing" pointcut-ref = "pt"/>
		</aop:aspect>	
		
	</aop:config>
	
</beans>  

package spring_ioc.h_aop_xml;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
	 private ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml",getClass());
	 // jdk代理(注意:目标类UserDao实现IUserDao接口!)
	@Test
	public void testApp() throws Exception {
		//从Spring的IOC容器中获取对象,使用接口接收！
		IUserDao userDao = (IUserDao)ac.getBean("userDao");
		System.out.println(userDao.getClass());
		userDao.save();
		
		/*//使用接口接收会报错:java.lang.ClassCastException: $Proxy13 cannot be cast to spring_ioc.g_aop_anno.UserDao
		UserDao userDao = (UserDao)ac.getBean("userDao");
		System.out.println(userDao.getClass());
		userDao.save();*/
		
		/*总结:在Spring的AOP编程中,符合切入点表达式的目标类,如果目标类有实现接口,从容器中获取目标对象的时候一定要通过接口接收否则会报错！
		 * 
		 */
	}
	
	
	//cglib代理(注意:目标类UserDao未实现IUserDao接口!)
	@Test
	public void testApp2(){
		UserDao userDao = (UserDao) ac.getBean("userDao");
		System.out.println(userDao.getClass());
		userDao.save();
	}
	
	
	//测试：没有被切入点表达式拦截的类(OrderDao)是不会生成代理对象的！
	@Test
	public void testApp3(){
		OrderDao orderDao = (OrderDao)ac.getBean("orderDao");
		orderDao.save();
	}
}

tespApp():


testApp2():(注意:UserDao实现IUserDao要取消,cglib代理目标类不能实现接口！)


testApp3():(切入点表达式未拦截OrderDao类,所以切面类没有起作用,仅仅输出OrderDao中的save()方法！)



参考资料：传智播客袁杰老师SpringAop讲解

1542161208
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
AOP-面向切面编程
Fengkx518的博客
02-28 288
文章目录1. AOP是什么？1.1 切面编程的原理1.2 步骤解析:1.3 用Spring简化源码1.4 代码解析 1. AOP是什么？ AOP是面向切面编程 在不修改源码的条件下,对方法进行扩展!!! 解决了业务的耦合性 在我们平时写代码时，在控制层会实现各种方法，但是太多的代码写入将会代码冗余，如何解决这一个问题呢？ 那就需要用到Spring框架中AOP机制，面向切面编程 在控制层中我们只需要写入少量的和必须要写入的代码，其余的都放在切面类中，这样就可以解决了代码冗余的问题 1.1 切面编程的原理 原理
AOP面向切面编程
andyliu198571的博客
07-07 194
2.3 AOP面向切面编程 ​ 在软件行业中，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 注意 对于实现过接口的类在AOP时，使用基于JDK的动态代理来生成
AoP面向切面编程
pangpangben的博客
04-15 1660
AoP AoP:面向切面编程，对业务逻辑的各个部分进行隔离，使得业务逻辑的各个部分之间的耦合度降低。 通俗来讲：不修改源码的方式，在主干功能里添加新功能。 例如： 1、AoP底层使用动态代理 有两种动态代理情况： （1）有接口，使用JDK动态代理 创建接口实现类的代理对象，增强类的方法 （2）没有接口情况，使用CGLIB动态代理 创建子类的代理对象，增强类的方法 2、AoP(JDK的动态代理) JDK的动态代理：使用Proxy类的方法newProxyInstance方法来创建代理对象 第一个参数
Spring AOP面向切面编程实现原理方法详解
08-18
Spring AOP面向切面编程实现原理方法详解 面向切面编程（AOP）是Spring框架中的一个重要内容，通过预编译方式和运行期动态代理实现，在不修改源代码的情况下，给程序动态统一添加功能的一种技术。AOP可以对业务逻辑...
Spring4AOP 面向切面编程实例之方法拦截
10-13
Spring4AOP 面向切面编程实例之方法拦截实例 一下利用Spring4的最后一个版本Spring4.3.9，实现简单的方法拦截实例。 Eclipse 建立java工程,导入必要的jar包，工程目录如下:
16.2 Spring框架-AOP面向切面编程
最新发布
04-12
面向切面编程（AOP，Aspect Oriented Programming）是Spring框架中的一个重要组成部分，它提供了一种模块化和声明式的方式来处理程序中的横切关注点，如日志、事务管理、性能监控等。在传统的OOP（面向对象编程）中...
Spring 面向切面编程AOP实现详解
08-25
Spring 面向切面编程AOP实现详解 面向切面编程（AOP）是一种编程技术，旨在将横切关注点从业务逻辑中分离出来，提高系统的可扩展性和可维护性。Spring 作为一个流行的 Java 框架，提供了完备的 AOP 实现机制。 1. ...
spring4 AOP 面向切面编程@Aspect
08-10
在Spring框架中，AOP（面向切面编程）是一种强大的设计模式，它允许开发者将关注点从业务逻辑中分离出来，比如日志记录、事务管理、权限检查等。`@Aspect`是Spring AOP的核心注解，用于定义一个切面。下面我们将详细...
Aop面向切面编程
ne_123456的博客
07-08 501
AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率.把业务核心代码和非核心业务代码分离，如果我们写的核心业务代码，需要非核心业务代码功能时，在不影响核心代码的前提下，可以
AOP——面向切面编程
azrealq的博客
11-16 458
1.什么是AOP 想必我们第一次接触这个概念一定会进行百度百科，那么我们先来看一下比较官方的说法 AOP就是Aspect Oriented Programming的缩写，也可以称为面向方面编程，它通过预编译和动态代理来实现，目的是对程序功能进行统一的维护。我们知道一个大型项目的成本不仅仅在于代码的编写，更是代码的维护，庞大的代码对维护很不友好。试想如果添加一个新的功能要在原有代码的基础上修改，而这部分代码又与很多地方的代码耦合，那么我们就要首先读懂相关部分的代码，并且在多个地方的源码进行修改，这是一件繁琐
AOP(面向切面编程)
StudyJava01的博客
12-08 1296
  我们在编写代码时，只想关注逻辑代码的实现。但是我们的程序是要放到服务器上去跑的，我们在代码中如果只有业务逻辑代码。虽然代码简洁，但是万一程序在服务器跑的时候数据出现问题时，没办法快速定位到问题所在。但是将日志等非逻辑代码和我们的逻辑代码放在一起，会使得代码冗余，代码的可读性难度加大。   基于上面的问题，Spring为我们提供了一种解决方案，将业务功能逻辑代码和非功能代码分开来写，然后使用动态代理，将非功能性代码嵌入到功能代码中，这就是所谓的AOP(面向切面编程)。  1、我们要使用Aop对我们的bea
AOP运行原理
Jay_456的博客
01-31 930
再者，如果增加一个方法，除了实现类需要实现这个方法外，所有的代理类也要实现此方法。简单的从字面意思看出：如果有接口，则使用 JDK 代理，反之使用 CGLIB ，这刚好印证了前文所阐述的内容。使用 JDK 生成的动态代理的前提是目标类必须有实现的接口。代理是一个中间层，它可以拦截对目标对象的访问，并在目标对象的方法执行前后插入额外的逻辑。通过代理和切点的结合，AOP可以在不修改原有代码的情况下，实现对横切关注点的增强。动态代理模式：动态代理类的源码是在程序运行期间，通过 JVM 反射等机制动态生成。
spring aop面向切面编程
08-15
对的，Spring AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架提供的一个重要特性。它允许开发者通过在应用程序中定义横切关注点（cross-cutting concerns），将这些关注点与核心业务逻辑分离开来。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值