spring系列(五):切面编程(aop)3

最新推荐文章于 2021-03-02 07:17:38 发布
最新推荐文章于 2021-03-02 07:17:38 发布
阅读量415 收藏
点赞数
分类专栏： spring 文章标签： spring aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wx5040257/article/details/78878645
版权

开发环境：jdk1.7     spring3.2.2

前两篇文章讲了各种增强处理，这篇文章再接着讲用注解定义增强以及切面编程的具体应用

一   用注解定义增强处理

除了实现Spring提供的特定接口，Spring还通过集成AspectJ实现了以注解的方式定义增强类，

大大减少了配置文件中的工作量。

增强处理代码

package com.obtk.advise;

import java.lang.reflect.Method;
import java.util.Arrays;

import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
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 com.obtk.entitys.UserEntity;

@Aspect
public class AnnotationAdvise {
	private static final Logger log = Logger.getLogger(AnnotationAdvise.class);

	/*
	@Before("execution(* com.obtk.dao.*.saveUser(..))")
	public void beforMeth(JoinPoint jp) {
		log.info("注解定义的前置增强==,调用者:"+jp.getTarget()
				      +",方法名:"+jp.getSignature().getName()
				       +",参数列表:"+Arrays.toString(jp.getArgs()));
	}
	
	@AfterReturning(pointcut="execution(* com.obtk.dao.*.saveUser(..))",returning="returnValue")
	public void afterMeth(JoinPoint jp,Object returnValue){
		log.info("注解定义的后置增强==,调用者:"+jp.getTarget()
				      +",方法名:"+jp.getSignature().getName()
				       +",参数列表:"+Arrays.toString(jp.getArgs())
				       +",返回值:"+returnValue);
	}
	
	@AfterThrowing(pointcut="execution(* com.obtk.dao.*.saveUser(..))",throwing="e")
	public void afterPaoChu(JoinPoint jp,RuntimeException e){
		log.info("注解定义的异常抛出增强==,调用者:"+jp.getTarget()
			      +",方法名:"+jp.getSignature().getName()
			       +",参数列表:"+Arrays.toString(jp.getArgs())
			       +",异常信息===>:"+e);
	}
	*/
	//注解定义环绕增强
	@Around("execution(* com.obtk.dao.*.saveUser(..))")
	public Object arundAdvise(ProceedingJoinPoint jp){
		log.info("注解定义的前置增强==,调用者:"+jp.getTarget()
			      +",方法名:"+jp.getSignature().getName()
			       +",参数列表:"+Arrays.toString(jp.getArgs()));
		Object result=null;
		try {
			result=jp.proceed();
			log.info("注解定义的后置增强==,调用者:"+jp.getTarget()
				      +",方法名:"+jp.getSignature().getName()
				       +",参数列表:"+Arrays.toString(jp.getArgs())
				       +",返回值:"+result);
		} catch (Throwable e) {
			log.info("注解定义的异常抛出增强==,调用者:"+jp.getTarget()
				      +",方法名:"+jp.getSignature().getName()
				       +",参数列表:"+Arrays.toString(jp.getArgs())
				       +",异常信息===>:"+e);
		}
		return result;
	}
}

切入点代码

package com.obtk.dao;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.ibatis.session.SqlSession;

import com.obtk.entitys.UserEntity;
import com.obtk.utils.MybatisUtil;

public class UserDaoImpl implements IUserDao{
	
	public int saveUser(UserEntity theUser) {
		System.out.println("方法执行前....");
		int result=0;
		SqlSession session=null;
		try {
			//4.得到session
			session=MybatisUtil.getSession();
			//5.执行语句
			result=session.insert("user.saveOne", theUser);
			session.commit();
			//添加完成可以取出启动增长的主键
			System.out.println("添加成功!");
		} catch (Exception e) {
			System.out.println("抛出了异常");
			session.rollback();
			throw new RuntimeException("发生了异常");
		}finally{
			MybatisUtil.closeSession();
		}
		return result;
	}
	
}
配置 

<?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-3.0.xsd
	                    http://www.springframework.org/schema/aop
	                    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
	
	<bean id="userDao" class="com.obtk.dao.UserDaoImpl"></bean>
	<!-- 增强处理的代码 -->
	<bean id="aspectBean" class="com.obtk.advise.AnnotationAdvise"></bean>
	
	<!-- 启动增强处理注解的支持 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>


二  aop具体应用

1.  用环绕增强统一处理事务问题

要切入的代码

package com.obtk.dao;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.ibatis.session.SqlSession;

import com.obtk.entitys.UserEntity;
import com.obtk.utils.MybatisUtil;

public class UserDaoImpl implements IUserDao {

	public int saveUser(UserEntity theUser) throws RuntimeException{
		// 4.得到session
		SqlSession session = MybatisUtil.getSession();
		System.out.println("程序代码中的对象哈希码:"+session.hashCode());
		// 5.执行语句
		int result = session.insert("user.saveOne", theUser);
		// 添加完成可以取出启动增长的主键
		System.out.println("添加成功!");
		return result;
	}

}
这里没有任何事务及异常处理，统一交给增强处理的代码完成

增强处理的代码如下：

package com.obtk.advise;

import java.lang.reflect.Method;
import java.util.Arrays;

import org.apache.ibatis.session.SqlSession;
import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
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 com.obtk.entitys.UserEntity;
import com.obtk.utils.MybatisUtil;

@Aspect
public class AnnotationAdvise {
	private static final Logger log = Logger.getLogger(AnnotationAdvise.class);

	@Around("execution(* com.obtk.dao.*.saveUser(..))")
	public Object arundAdvise(ProceedingJoinPoint jp){
		Object result=null;
		SqlSession session=MybatisUtil.getSession();
		System.out.println("增强处理的代码对象哈希码:"+session.hashCode());
		try {
			result=jp.proceed();
			session.commit();
		} catch (Throwable e) {
			session.rollback();
			e.printStackTrace();
		}finally{
			MybatisUtil.closeSession();
		}
		return result;
	}
}
配置 

<?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-3.0.xsd
	                    http://www.springframework.org/schema/aop
	                    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
	
	<bean id="userDao" class="com.obtk.dao.UserDaoImpl"></bean>
	<!-- 增强处理的代码 -->
	<bean id="aspectBean" class="com.obtk.advise.AnnotationAdvise"></bean>
	
	<!-- 启动增强处理注解的支持 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

2   转账案例

简单模拟账户表




dao层代码

package com.obtk.dao;

import org.hibernate.Query;
import org.hibernate.Session;

public class AcctDaoImpl implements IAcctDao{
	@Override
	public void doPay(int payId, double amount) throws RuntimeException{
		String hql="update AcctEntity set balance=balance-? where acctId=?";
		Session session=HiberUtil.getSession();
		Query qy=session.createQuery(hql);
		qy.setParameter(0, amount);
		qy.setParameter(1, payId);
		int result=qy.executeUpdate();
		if(result==0){
			throw new RuntimeException("付款失败");
		}
	}
	
	@Override
	public void doReceive(int receiveId, double amount) {
		String hql="update AcctEntity set balance2=balance+? where acctId=?";
		Session session=HiberUtil.getSession();
		Query qy=session.createQuery(hql);
		qy.setParameter(0, amount);
		qy.setParameter(1, receiveId);
		int result=qy.executeUpdate();
		if(result==0){
			throw new RuntimeException("收款失败");
		}
	}
	
}



切入点不能配置在dao层

建立业务层biz

package com.obtk.biz;

import com.obtk.dao.IAcctDao;


public class AcctBiz {
	private IAcctDao acctDao;
	
	public void setAcctDao(IAcctDao acctDao) {
		this.acctDao = acctDao;
	}
	
	//一个业务调用多个dao层的方法
	public void doTransfer(int payId,int receiveId, double amount) throws RuntimeException{
		acctDao.doPay(payId, amount);
		acctDao.doReceive(receiveId, amount);
	}
	
	
}
切入点配置在biz层 
package com.obtk.advise;


import org.apache.log4j.Logger;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.hibernate.Session;
import org.hibernate.Transaction;

import com.obtk.dao.HiberUtil;

@Aspect
public class AnnotationAdvise {
	@Around("execution(* com.obtk.biz.*.do*(..))")
	public Object arundAdvise(ProceedingJoinPoint jp){
		Object result=null;
		Session session=HiberUtil.getSession();
		System.out.println("增强处理的代码对象哈希码:"+session.hashCode());
		Transaction tx=null;
		try {
			tx=session.beginTransaction();
			result=jp.proceed();
			tx.commit();
		} catch (Throwable e) {
			System.out.println("我回滚了");
			tx.rollback();
			e.printStackTrace();
		}finally{
			HiberUtil.closeSession();
		}
		return result;
	}
}
配置 

<?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-3.0.xsd
	                    http://www.springframework.org/schema/aop
	                    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
	
	<bean id="userDao" class="com.obtk.dao.UserDaoImpl"></bean>
	<bean id="acctDao" class="com.obtk.dao.AcctDaoImpl"></bean>
	<bean id="acctBiz" class="com.obtk.biz.AcctBiz">
		<property name="acctDao" ref="acctDao"></property>
	</bean>
	<!-- 增强处理的代码 -->
	<bean id="aspectBean" class="com.obtk.advise.AnnotationAdvise"></bean>
	
	<!-- 启动增强处理注解的支持 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>














御前两把刀刀
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring学习-Spring项目规范
qq_48772498的博客
05-06 1104
一.分层规范概述 一个常见的基于 Spring 搭建起来的后端服务大体如下： 在当前工程中，现在除了启动类和配置文件，目前还没有什么功能。从工程的角度上来看，需要构建好一个分层体系，来承载我们的业务 二.分层规范视图 三. API 层 1.API 层开发视图 2.API 层主要承接前端请求，对外提供的协议主要包括 Http 和 Thrift 两大类协议，这里先以 Http 接口为例，介绍 API 层的设计 四.Biz 层 1.Biz 层开发视图 2. Biz
Spring底层原理及其主要知识点（一）
m0_46741750的博客
07-03 581
什么是Spring Spring是一个轻量级的java开发框架，是为了解决企业级应用开发的业务逻辑层和其它各层的耦合问题，实现解耦合。 Spring最基本的使命是解决企业级应用开发的复杂性，及简化java开发。 Spring可以做很多功能，但是这些功能的底层都依赖于它的两个核心特性，也就是依赖注入（dependency injection)也就是控制反转（ioc）和面向切面编程（AOP） 基于POJO的轻量级和最小侵入性编程； 通过依赖注入和面向接口实现松耦合； 基于切面和惯例进行声明式编程； 通过切面和
SpringAOP面向切面详解（带实例）
热门推荐
迹_Jason
05-13 1万+
了解AOP的相关术语1.通知(Advice):通知定义了切面是什么，以及何时使用。描述了切面要完成的工作和何时需要执行这个工作。2.连接点(Joinpoint):程序能够应用通知的一个“时机”，这些“时机”就是连接点，例如方法被调用时、异常被抛出时等等。3.切入点(Pointcut):通知定义了切面要发生的“故事”和时间，那么切入点就定义了“故事”发生的地点，例如某个类或方法的名称，Spring中允
Spring Boot多模块项目搭建介绍
记录只为更好地前行
10-20 1039
Spring Boot多模块项目搭建介绍 本文主要介绍如何使用IDEA搭建多模块的Spring Boot项目，项目使用Spring Boot + MyBatis的技术架构。 一、搭建父模块 使用IDEA新建一个Project： 选择Spring Initializr，点击【Next】： 填写项目的GroupId、ArtifactId等项目信息，因为是示例代码，所以这些项目信息都填写为...
[Java][web]利用Spring随时随地获得Request和Session
cihongmo6452的博客
05-26 218
利用Spring随时随地获得Request和Session 一、准备工作： 在web.xml中添加 <listener> <listener-class> org.springframework.w...
揭秘AOP：切面编程的综合指南配套演示项目资源
最新发布
03-23
本资源包是《揭秘AOP：切面编程的综合指南》一书的配套演示项目，旨在通过实际操作帮助读者深入理解AOP的概念、原理以及在Spring中的实现。 **AOP核心概念** 1. **切面（Aspect）**：切面是关注点的一个模块化，它...
Spring 面向切面编程AOP实现详解
08-25
Spring 面向切面编程AOP实现详解 面向切面编程（AOP）是一种编程技术，旨在将横切关注点从业务逻辑中分离出来，提高系统的可扩展性和可维护性。Spring 作为一个流行的 Java 框架，提供了完备的 AOP 实现机制。 1. ...
Spring AOP面向切面编程实现原理方法详解
08-18
Spring AOP面向切面编程实现原理方法详解 面向切面编程（AOP）是Spring框架中的一个重要内容，通过预编译方式和运行期动态代理实现，在不修改源代码的情况下，给程序动态统一添加功能的一种技术。AOP可以对业务逻辑...
Spring AOP 切面编程实战Demo项目
01-26
2、面向切面编程AOP 在实现过程中，我尽量贴近实际开发与场景，麻雀虽小，五脏俱全，个人感觉这个项目是web框架搭建的一个极简之道实践。 项目中可能还存在很多的问题，希望大家不吝赐教，谢谢。
使用Spring框架实现AOP切面编程.zip
03-09
本资源通过一个Category和Publisher表的实例，使用Spring框架实现AOP切面编程，其中实现了增删改查的功能，通过事物(tx)管理器、扫描业务逻辑、声明式事务达到切面编程效果。代码中有很详细的备注，适合新手入门
springmvc中获取request对象，加载biz(service)的方法
hezhoujun的专栏
06-28 5762
获取request对象： 首先配置web.xml文件--> org.springframework.web.context.request.RequestContextListener 然后在程序中获取: 代码: HttpServletRequest request = ((ServletRequestAttri
Java工程为什么要加一个biz层
11-21 3719
biz是Business的缩写，实际上就是控制层（业务逻辑层）。解释：控制层的主要作用就是协调model层和view层直接的调用和转换。能够有效的避免请求直接进行数据库内容调用，而忽略了逻辑处理的部分。实际上biz就起到了一个server服务的角色，很好的沟通了上层和下层直接的转换，避免在model层进行业务处理（代码太混乱，不利于维护）。 转载于:https://www.cnblog...
java+bizx文件_14.Teambiz后台开发规范
weixin_29496633的博客
03-02 821
IBM GDC DLTeambiz后台开发规范(2012年3月9日修订版)撰写：何杨2012年3月9日1. 包的命名包名应全由小写单词组成，如com.dalpha.common.gui，com.dalpha.biz.supply2. 接口的命名Java接口采用统一的前缀I，如IService.java3. 接口实现类的定义接口实现类建议采用统一的后缀Impl，如：ServiceImpl4. 抽象类...
Spring学习（一）—入门
mingxin95的博客
07-03 1344
Spring是什么？ Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson创建。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架。 struts是web框架，Hibernate是O/RM框架 Spring是容器框架，用于配制bean并维护bean之间关系的框架。 Spring
Spring AOP：面向切面编程详解与应用整合
2. **灵活性**：Spring AOP与IoC（Inversion of Control）完美结合，允许开发者在运行时动态地定义切面和连接点（JoinPoint），适应不断变化的业务需求。 3. **解耦与扩展性**：通过AOP，模块之间的耦合度降低，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

御前两把刀刀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值