AOP第二部分应用-事务管理

Spring Boot开发 (4) :事务管理、AOP,Spring原理、Maven高级 JavaWeb开发——SSM高级:事务管理、AOP,Spring原理、Maven高级。在实际开发中,经常会定义一些公共组件,提供给各个项目团队使用。而在SpringBoot的项目中,一般会将这些公共组件封装为SpringBoot的starter。 阅读详情


    一、编写Hibernate的Dao

  在该封装好的类中,并没有事务的处理,事务的处理交给AOP来处理,代码如下:

package cn.com.bochy.dao;
import java.util.List;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
public class HibernateUntil<T> {
 private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();
 private static org.hibernate.SessionFactory sessionFactory;
 private static Configuration configuration = new Configuration();
 private static ServiceRegistry serviceRegistry;
 static {
  try {
   configuration.configure();
   serviceRegistry = new ServiceRegistryBuilder().applySettings
   (configuration.getProperties()).buildServiceRegistry();
   sessionFactory = configuration.buildSessionFactory(serviceRegistry);
  } catch (Exception e) {
   System.err.println("%%%% Error Creating SessionFactory %%%%");
   e.printStackTrace();
  }
 }

 public HibernateUntil() {

 }

 public Session getSession() throws HibernateException {
  Session session = threadLocal.get();
  if (session == null || !session.isOpen()) {
   if (sessionFactory == null) {
    rebuildSessionFactory();
   }
   session = (sessionFactory != null) ? sessionFactory.openSession()
     : null;
   threadLocal.set(session);
  }
  return session;
 }

 public void rebuildSessionFactory() {
  try {
   configuration.configure();
   serviceRegistry = new ServiceRegistryBuilder().applySettings

   (configuration.getProperties()).buildServiceRegistry();
   sessionFactory = configuration.buildSessionFactory(serviceRegistry);
  } catch (Exception e) {
   System.err.println("%%%% Error Creating SessionFactory %%%%");
   e.printStackTrace();
  }
 }

 public void closeSession() throws HibernateException {
  Session session = getSession();
  threadLocal.set(null);

  if (session != null) {
   session.close();
  }
 }

 public org.hibernate.SessionFactory getSessionFactory() {
  return sessionFactory;
 }

 public Configuration getConfiguration() {
  return configuration;
 }

 @SuppressWarnings("unchecked")
 public List<T> getList(String hql) {
  Session session = getSession();
  Query query = session.createQuery(hql);
  List<T> lis = null;
  lis = query.list();
  return lis;
 }

 public boolean Save(T obj) {
  Session session = getSession();

  boolean mark = true;
  try {
   session.save(obj);

  } catch (Exception e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
   mark = false;
  }
  return mark;
 }

 public boolean update(T obj) {
  Session session = getSession();
  boolean mark = true;
  try {
   session.saveOrUpdate(obj);
  } catch (Exception e) {
   // TODO Auto-generated catch block
   mark = false;
   e.printStackTrace();
  }
  return mark;
 }

 @SuppressWarnings("unchecked")
 public T getObjectById(int id, Class<T> c) {
  Session session = getSession();
  T obj = null;
  try {
   obj = (T) session.get(c, id);
  } catch (Exception e) {
   // TODO Auto-generated catch block
   e.printStackTrace();

  }
  return obj;
 }

 public boolean delete(T obj) {
  Session session = getSession();
  boolean mark = true;
  try {
   session.delete(obj);

  } catch (Exception e) {
   // TODO Auto-generated catch block
   mark = false;
   e.printStackTrace();
  }
  return mark;
 }

 /**
  * 分页
  */
 @SuppressWarnings("unchecked")
 public List<T> Page(String hql, int pageIndex, int pageSize) {
  Session session = getSession();
  List<T> lis = null;
  try {
   Query query = session.createQuery(hql);
   query.setFirstResult((pageIndex - 1) * pageSize);
   query.setMaxResults(pageSize);
   lis = query.list();
  } catch (HibernateException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  return lis;
 }
}

  二、定义一个接口

package cn.com.bochy.istu;
import java.util.List;
import cn.com.bochy.entity.Stu;
public interface IStuBiz {
  public List<Stu> getAll();
  public boolean save(Stu s);
  public boolean update(Stu s);
  public boolean delete(int id);
  public Stu getStuByID(int id);
}

三、接口的实现类

在这个实现类中,也没有对事务进行处理

package cn.com.bochy.istuImpl;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import cn.com.bochy.dao.HibernateUntil;
import cn.com.bochy.entity.Stu;
import cn.com.bochy.istu.IStuBiz;
public class StuBizImpl implements IStuBiz {
 HibernateUntil<Stu> util=new HibernateUntil<>();
 private Session session=util.getSession();
 @SuppressWarnings("unchecked")
 @Override
 public List<Stu> getAll() {   
        Query query=session.createQuery("from Stu");
  return query.list();
 }
 @Override
 public boolean save(Stu s) {
 System.out.println("save a stu....");
   session.save(s);
  return true;
 }
 @Override
 public boolean update(Stu s) {
   session.saveOrUpdate(s);
   return true;
 }
 @Override
 public boolean  delete(int id) {
    Stu s=(Stu)session.get(Stu.class, id);
   session.delete(s);
   return true;
 }
 @Override
 public Stu getStuByID(int id) {
   Stu s=(Stu)session.get(Stu.class, id);
  return s;
 }
}
四、使用环绕通知管理事务

 需要注意的是,以get方法开头的所有方法,属于查询方法,没有加入事务管理。

package cn.com.bochy.advices;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.hibernate.Session;
import org.hibernate.Transaction;
import cn.com.bochy.dao.HibernateUntil;
import cn.com.bochy.entity.Stu;
public class aroundAdvice implements MethodInterceptor{
 HibernateUntil<Stu> util=new HibernateUntil<>();
 @Override
 public Object invoke(MethodInvocation arg0) throws Throwable {
  Object result=null;
  Transaction tx=null;
   String methodName=arg0.getMethod().getName();
    if(methodName.startsWith("get")){
     result=arg0.proceed();//调用主业务逻辑
     return result;
    }  
   try {
     Session session=util.getSession();
    tx=session.beginTransaction();
    System.out.println("开启事务....");
   result=arg0.proceed();//调用主业务逻辑
   tx.commit();
    result=true;
   System.out.println("事务提交");
  } catch (Exception e) {
     tx.rollback();
  result=false;
   System.out.println("事务回滚");
  }    
  return result;
 }
}
五、配置ApplicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd" >
<beans>
   <bean id="stu" class="cn.com.bochy.entity.Stu"></bean>
   <bean id="stuBiz" class="cn.com.bochy.istuImpl.StuBizImpl"></bean>
   <bean  id="around" class="cn.com.bochy.advices.aroundAdvice"></bean>
   <!-- 把横切业务逻辑织入主业务逻辑 -->
   <bean id="aop" class="org.springframework.aop.framework.ProxyFactoryBean">
   <!-- 指定代理类和被代理类共同的接口 -->
     <property name="interfaces" value="cn.com.bochy.istu.IStuBiz"></property>
     <!-- 指定所有的拦截器(织入横切业务逻辑) -->
     <property name="interceptorNames">
     <list>
    <value>around</value>
     </list>
     </property>
      <!-- 指定横切业务逻辑在哪里执行 ,执行的目标 -->
      <property name="target" >
      <ref bean="stuBiz"/>
      </property>
   </bean>
</beans>
六、测试代码

package cn.com.bochy.test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import cn.com.bochy.entity.Stu;
import cn.com.bochy.istu.IStuBiz;
public class TestAOP {
  public static void main(String[] args) {
 @SuppressWarnings("resource")
 ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
   IStuBiz biz=(IStuBiz)ac.getBean("aop");
              Stu s=new Stu();
           s.setName("aop5");
           System.out.println(biz.save(s));
}
}

测试结果:

开启事务....
save a stu....
Hibernate:
    select
        stu_seq.nextval
    from
        dual
Hibernate:
    insert
    into
        Stu
        (name, id)
    values
        (?, ?)
事务提交
true

第五章:【springboot】框架事务管理与Aop 动态代理是面向切面编程最主流的实现,而Spring AOP是spring框架的高级技术,旨在管理bean对象的过程中,主要通过底层的动态代理机制,对特定的方法进行编程。默认情况下,只有出现 RuntimeException(运行时异常) 才回滚异常。当有多个切面的切入点都匹配到了目标方法,目标方法运行时,多个通知方法都会被执行。事务是一组操作的集合,他是一个不可分割的工作单位,要么同时成功,要么同时失败。面向切面,面向方面编程,其实就是面向特定的方法编程。不同切面类中,默认按切面类的类名字母排序。 阅读详情

相关推荐

大数据运维面试题及答案

1. 架构组成:- 2 个 NameNode(Active 活跃节点、Standby 备用节点),实时同步元数据(通过 JournalNode 集群,默认 3 个节点,存储 edits 日志,Active 写入、Standby 读取以保持元数据一致);- 容错性强:通过 RDD 的 “ lineage(血缘)” 机制,任务失败时可快速重算,无需从头执行。:集群 “大脑”,管理元数据(文件目录、块位置),实时响应客户端请求,数据存于内存,元数据镜像(fsimage)和编辑日志(edits)持久化到磁盘;

weixin_42795092的博客 908

Spring 事务管理-AOP

事务管理,SpringAOP笔记

2301_79070677的博客 1238

俄罗斯方块 C++控制台版

一、创建方块 wstring tetromino[7]; tetromino[0].append(L"..X...X...X...X."); // Tetronimos 4x4 tetromino[1].append(L"..X..XX...X....."); tetromino[2].append(L".....XX..XX....."); tetromino[3].append(L"..X..XX..X......"); tetromino...

一只大鸽子的博客 1625

基于Aop实现Spring事务管理详解

这样,在addUser方法执行过程中,如果发生异常,事务会自动回滚,确保数据的一致性。Spring通过AOP拦截器实现了对事务方法的拦截和增强,然后根据方法的声明式事务设置,在AOP拦截器中启动或加入事务,最终控制事务的提交或回滚。在Spring中,AOP和事务管理可以同时使用,通过在事务管理中配置AOP拦截器,可以在事务管理的基础上实现更细粒度的控制。这样,在程序运行时,当调用UserService的addUser方法时,Spring AOP会拦截该方法的调用,并在增强逻辑中启动和管理事务。

weixin_53050118的博客 1899

单相PWM整流器四象限运行原理

简述单相PWM整流器四象限运行原理。

m0_75208156的博客 8308

AI工程化之生成式UI & A2UI(二)

本文介绍了生成式UI框架A2UI的架构设计与核心实现。项目采用AI协作开发模式,通过ATDD(AI驱动的测试驱动开发)确保代码质量。前端SDK基于zustand实现框架无关的状态管理,包含协议解析器、存储管理、渲染器等核心模块。重点展示了基础store构建、A2UI协议解析器的实现过程,包括mock数据准备、测试用例生成和可视化调试。项目采用monorepo管理,利用vite实现高效开发构建。整个系统设计遵循模块化原则,通过清晰的接口定义实现各组件解耦,为后续功能扩展打下基础。

qq_34306228的博客 407

Java——事务管理与AOP

本文介绍了Spring事务管理与AOP编程的核心概念。在事务管理方面,讲解了事务的四大特性(原子性、一致性、隔离性、持久性)及Spring的@Transactional注解使用,重点分析了事务传播行为(如REQUIRED和REQUIRES_NEW)和异常回滚机制。在AOP方面,阐述了面向切面编程的思想,详细说明了五种通知类型(@Around、@Before等)的执行顺序控制,以及两种切入点表达式(execution和@annotation)的使用方法。文章还介绍了连接点(JoinPoint)的概念及其在方法

2401_86951043的博客 951

第33次CCF-CSP认证考试 第一题 词频统计 满分题解

本人小白一枚,抱着学习的态度想到网上找一些csp的参考答案,但由于实力有限,大佬的代码大都看不太懂,于是萌生了想用一些简单,基础的语句完成csp前两题的想法并公开,以便与像我这样实力不强的同学交流学习,如有更好的建议,还请斧正,感谢!

qq_75242106的博客 1870

JavaWeb——013SpringBootWeb综合案例(事务管理、AOP)

我们接着继续学习@Transactional注解当中的第二个属性propagation,这个属性是用来配置事务的传播行为的。什么是事务的传播行为呢?就是当一个事务方法被另一个事务方法调用时,这个事务方法应该如何进行事务控制。例如:两个事务方法,一个A方法,一个B方法。在这两个方法上都添加了@Transactional注解,就代表这两个方法都具有事务,而在A方法当中又去调用了B方法。

pangyaqi的博客 1114

RSL-RL:开源人形机器人强化学习控制研究库

摘要:RSL-RL是一款专为机器人领域设计的开源强化学习库,其核心特点是紧凑性、可修改性和高性能。该库聚焦PPO和BC两大主流算法,并整合了对称性增强、好奇心驱动等机器人专用技术。通过纯GPU训练优化,RSL-RL在大型仿真中展现出卓越的吞吐性能,已成功应用于腿足运动控制、全身协调等多个机器人研究场景。其轻量级架构包含运行器、算法和网络三个可独立修改的组件,支持TensorBoard等主流日志工具。该框架特别适合需要快速原型开发的机器人研究者,但不适用于通用机器学习基准测试。开源地址:https://git

2506_90492529的博客 1680

SAR成像概述

1. 发展概述 雷达是英文Radar(Radio detection and ranging)的音译,原意为“无线电探测与测距”。雷达的发明是无线电发展史上的里程碑,二战时,英国急需通过雷达探测空中金属物体来帮助搜寻德国飞机,这期间,雷达技术飞速发展,发展出了地对空、空对地轰炸、空对空火控、敌我识别等功能。雷达在第二次世界大战中发挥了重大作用,至今仍是军用和许多民用领域的重要传感器。 早期雷达系统通过时间延迟来测距,通过天线指向来测角,通过多普勒频移测速。1951年,Carl Wiley发现,通..

5079

AOP总结&事务管理

事务作用:在数据层保障一系列的数据库操作同成功同失败Spring事务作用:在数据层或业务层保障一系列的数据库操作同成功同失败数据层有事务我们可以理解,为什么业务层也需要处理事务呢?举个简单的例子,转账业务会有两次数据层的调用,一次是加钱一次是减钱把事务放在数据层,加钱和减钱就有两个事务没办法保证加钱和减钱同时成功或者同时失败这个时候就需要将事务放在业务层进行处理。Spring为了管理事务,提供了一个平台事务管理器commit是用来提交事务,rollback是用来回滚事务。

Eumenides_Suki的博客 1195

《测控仪器设计课后习题答案-浦昭邦-王宝光

《测控仪器设计课后习题答案-浦昭邦-王宝光 1.1. 测控仪器的概念是什么? 测控仪器则是利用测量和控制的理论,采用机、电、光各种计量测试原理及控制系统与计算机相结合的一种范围广泛的测量仪器。 1.2. 为什么说测控仪器的发展与科学技术发展密切相关? 仪器仪表的用途和重要性— 遍及国民经济各个部门,深入到人民生活的各个角落,仪器仪表中的计量测试仪器与控制仪器统称为测控仪器,可以说测控仪器的水平是科学技术现代化的重要标志。 仪器仪表的用途: 在机械制造业中:对产品的静态与动态性能测试;加工过程的控制与监测;设

无名何许人的博客 2979

事务管理+AOP

使用@Transactional开启事务(一般添加在方法上,类、接口也可以)异常回滚的属性:rollbackFor;默认异常回滚属性为“运行时异常”,使用rollbackFor可以指定异常回滚类型。使用格式:@Transactional(rollbackFor=Exception.class)事务传播行为:propagation;默认事务方法A调用事务方法B,出现回滚时两个方法执行的内容都要回滚;如果希望事务方法A和事务方法B作为两个独立的方法(一方出现异常回滚不能影响另一方。

m0_62762293的博客 1122

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

事务管理与 AOP

是一种编程思想,用于动态地将某些通用功能(如日志记录、性能监控、事务管理等)附加到目标方法中,而无需修改目标方法的代码。它由以下几个部分组成连接点(JoinPoint)可以被 AOP 控制的方法(暗含方法执行时的相关信息)通知(Advice)指定义的重复逻辑,也就是共性功能(最终体现为一个方法)切入点(PointCut)匹配连接点的条件,通知仅会在符合切入点的条件时应用 )切面(Aspect)描述通知与切入点的对应关系(通知 + 切入点)目标对象(Target)通知所应用的对象。

qq_74018743的博客 695

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

JavaWeb合集09-事务管理与AOP

例子:比如项目部分功能运行较慢,定位执行耗时较长的业务方法,此时需要统计每一个业务方法的执行耗时,这时就可以使用一个模板,当运行方法前,先计算当前时间,方法运行后,再统计当前时间,两个时间相减就得到了方法运行的耗时。(日志信息包含:操作人、操作时间、执行方法的全类名、执行方法名、方法运行时参数、返回值、方法执行时长)②目标方法后的通知方法:字母排名靠前的后执行;④ * :单个独立的任意符号,可以通配任意返回值、包名、类名、方法名、任意类型的-一个参数,也可以通配包、类、方法名的一部分。

qq_57340195的博客 1026

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

【JavaWeb】事务管理 & AOP

AOP:Aspect Oriented Programming(面向切面编程、面向方面编程),其实就是面向特定方法编程。应用场景:案例部分功能运行较慢,定位执行耗时较长的业务方法,此时需要统计每一个业务方法的执行耗时那么我们该如何统计每一个业务方法的执行耗时呢?目前我们能想到的就只有在方法执行前记录开始时间,在方法执行后记录结束时间,以此来计算方法的执行耗时AOP动态代理是面向切面编程最主流的实现。

一以贯之的努力 不得懈怠的人生 588

Spring AOP学习(2)——AOP的应用(事务管理)

说说Spring事务管理 什么是事务? 事务(Transaction),一般是指要做的或所做的事情。指一个工作单元,它包含了一组数据操作命令,并且所有的命令作为一个整体一起向系统提交或撤消请求操作,即这组命令要么都执行,要么都不执行。 在计算机术语中是指访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。 spring事务管理 Spring事务的本质其实就是数据库对事务的支持,没...

Liucheng0的博客 574

day07事务管理和AOP

默认情况下,只有出现RuntimeException(比如1/0)才回滚异常。

weixin_46164192的博客 1840

AOP概述及应用&Spring中的事务管理

AOP 概述 AOP 为 Aspect Oriented Programming 的缩写,意为:面向切面编程,通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。 AOP 是 OOP 的延续,是软件开发中的一个热点,也是 Spring 框架中的一个重要内容。利用 AOP 可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。 AOP、OOP 在字面上虽然非常类似,但却是面向不同领域的两种设计思想。OOP(面向对象编程)针对业务处理过

qq_44165855的博客 434

spring事务管理 和 Spring AOP

Transactional作用:就是在当前这个方法执行开始之前来开启事务,方法执行完毕之后提交事务。如果在这个方法执行的过程当中出现了异常,就会进行事务的回滚操作。@Transactional注解:我们一般会在业务层当中来控制事务,因为在业务层当中,一个业务功能可能会包含多个数据访问的操作。在业务层来控制事务,我们就可以将多个数据访问操作控制在一个事务范围内。

sdg_advance的博客 1188

JavaWeb——事务管理、AOP

Aspect Oriented Programming(面向切面编程、面向方面编程),其实就是面向特定方法编程。private,仅能在当前切面类中引用该表达式,public,在其他外部的切面类中也可以引用该表达式。切入点:PointCut,匹配连接点的条件,通知仅会在切入点方法执行时被应用。当有多个切面的切入点都匹配到目标方法,目标方法运行时,多个通知方法都会被执行。当一个事务方法被另一个事务方法调用时,这个事物方法应该如何进行事物控制。切面:Aspect,描述通知与切入点的对应关系(通知+切入点)

l_tian_tian_的博客 556

什么事aop,aop的作用是什么?aop在项目哪里使用到了

面向切面编程(AOP)提供另一种角度来思考程序结构,通过这种方式弥补了 面向对象编程(OOP)的不足,除了类(classes)以外,AOP提供了切面。 切面对关注点进行模块化,例如横切多个类型和对象的事务管理。 Spring的一个关键的组件就是Aop框架,可以自由选择使用AOP提供声明式企业服务,特别是为了替代EJB声明式服务。最重要的服务是声明性事务管理,这个服务建立在Spring的抽象事务管理...

weixin_43893935的博客 1万+

Web后端开发(事务管理、AOP)

文章系统介绍了Spring框架中的事务管理和AOP技术。事务管理部分阐述了事务概念、Spring事务管理实现方式及进阶配置(rollbackFor和propagation)。AOP部分详细讲解了AOP基础概念(通知、切入点、切面等)、快速入门方法、核心执行流程,以及进阶使用技巧(通知类型、执行顺序、表达式等)。重点说明了AOP通过动态代理实现方法增强的特性,并提供了事务日志配置示例。全文兼顾理论概念与实践指导,全面覆盖Spring两大核心功能模块。

2401_88455976的博客 993

事务管理&AOP

AOP:Aspect Oriented Programming(面向切面编程、面向方面编程),其实就是面向特定方法编程。场景:案例部分功能运行较慢,定位执行耗时较长的业务方法,此时需要统计每一个业务方法的执行耗时。实现:动态代理是面向切面编程最主流的实现。而SpringAOP是Spring框架的高级技术,旨在管理bean对象的过程中,主要通过底层的动态代理机制,对特定的方法进行编程。

lz1838156237的博客 1087

AOP面向切面

事务&AOP 1. 事务管理 1.1 事务回顾 在数据库阶段我们已学习过事务了,我们讲到: 事务是一组操作的集合,它是一个不可分割的工作单位。事务会把所有的操作作为一个整体,一起向数据库提交或者是撤销操作请求。所以这组操作要么同时成功,要么同时失败。 怎么样来控制这组操作,让这组操作同时成功或同时失败呢?此时就要涉及到事务的具体操作了。 事务的操作主要有三步: 开启事务(一组操作开始前,开启事务):start transaction / begin ; 提交事务(

qq_48283218的博客 2017
上一篇: AOP第一部分-基础
下一篇: 使用Spring的注解实现Hibernate事务管理
fullStackChenZF
博客等级 码龄10年 44粉丝 70原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值