`
lzkyo
  • 浏览: 466071 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Spring2.X以AspectJ 式AOP 配置事务

AOP配置管理BeanHibernateSpring 
阅读更多
(1)配置:
    Spring的事务管理是通过AOP代理实现的，其中的事务通知由元数据驱动。代理对象与事务元数据结合产生一个AOP代理，它使用一个PlatformTransactionManager实现，配合TransactionInterceptor,在方法调用前后实施事务。
Java代码 复制代码
  1. <?xml version="1.0" encoding="UTF-8"?>   
  2.   
  3. <beans xmlns="http://www.springframework.org/schema/beans"    
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    
  5.     xmlns:context="http://www.springframework.org/schema/context"    
  6.     xmlns:aop="http://www.springframework.org/schema/aop"    
  7.     xmlns:tx="http://www.springframework.org/schema/tx"    
  8.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd    
  9.     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd    
  10.     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd    
  11.     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">   
  12.   
  13.     <description>springApp</description>       
  14.     <!-- dataSource for MySQL -->   
  15.     <bean id="dataSource"  
  16.         class="org.apache.commons.dbcp.BasicDataSource"  
  17.         destroy-method="close">   
  18.         <property name="driverClassName"  
  19.             value="com.mysql.jdbc.Driver" />   
  20.         <property name="url"  
  21.             value="jdbc:mysql://localhost:3306/springapp" />   
  22.         <property name="username" value="root" />   
  23.         <property name="password" value="****" />   
  24.     </bean>      
  25.   
  26.     <!-- Hibernate SessionFactory for MySQL -->   
  27.     <bean id="sessionFactory"  
  28.         class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">   
  29.         <property name="dataSource" ref="dataSource" />   
  30.   
  31.         <property name="mappingDirectoryLocations">   
  32.             <list>   
  33.                 <value>classpath:/</value>   
  34.             </list>   
  35.         </property>   
  36.         <property name="hibernateProperties">   
  37.             <props>   
  38.                 <prop key="hibernate.dialect">   
  39.                     org.hibernate.dialect.MySQLDialect   
  40.                 </prop>   
  41.                 <prop key="hibernate.show_sql">true</prop>   
  42.                 <prop key="hibernate.jdbc.fetch_size">50</prop>   
  43.                 <prop key="hibernate.jdbc.batch_size">100</prop>   
  44.             </props>   
  45.         </property>   
  46.   
  47.     </bean>   
  48.   
  49.   
  50.     <!--Transaction -->    
  51.     <bean id="txManager"    
  52.         class="org.springframework.orm.hibernate3.HibernateTransactionManager">    
  53.             <property name="sessionFactory" ref="sessionFactory" />    
  54.     </bean>    
  55.   
  56.     <aop:config> <!--use CGLIB:proxy-target-class="true-->   
  57.         <aop:pointcut id="serviceOperator" expression="execution(* com.logcd.business.service.*.*(..))"/>   
  58.         <aop:advisor  advice-ref="txAdvice" pointcut-ref="serviceOperator"/>    
  59.         <!--   
  60.         <aop:advisor pointcut="execution(* com.logcd.business.service..*Service.*(..))" advice-ref="txAdvice"/>          
  61.         -->   
  62.     </aop:config>    
  63.        
  64.     <tx:advice id="txAdvice" transaction-manager="txManager">    
  65.         <tx:attributes>    
  66.             <tx:method name="find*" read-only="true" />    
  67.             <tx:method name="load*" read-only="true" />    
  68.             <tx:method name="is*" read-only="true"/>    
  69.             <tx:method name="save*"    
  70.                 rollback-for="Exception"/>    
  71.             <tx:method name="insert*"    
  72.                 rollback-for="Exception" />    
  73.             <tx:method name="remove*"  
  74.                 rollback-for="Exception"/>    
  75.             <tx:method name="add*"  
  76.                 no-rollback-for="Exception" />    
  77.         </tx:attributes>    
  78.     </tx:advice>    
  79.     <!--Transaction -->    
  80.        
  81.     <!-- DAO -->   
  82.     <bean id="genericDao" lazy-init="true" abstract="true"  
  83.         class="com.logcd.bo.dao.impl.GenericDaoImpl">   
  84.         <property name="sessionFactory">   
  85.             <ref local="sessionFactory" />   
  86.         </property>   
  87.     </bean>   
  88.   
  89.     <bean id="customersDao" parent="genericDao"  
  90.         class="com.logcd.bo.dao.impl.CustomersDaoImpl" />   
  91.   
  92.     <bean id="customerDao" parent="genericDao"  
  93.         class="com.logcd.bo.dao.impl.CustomerDaoImpl" />   
  94.   
  95.     <bean id="addressDao" parent="genericDao"  
  96.         class="com.logcd.bo.dao.impl.AddressDaoImpl" />   
  97.   
  98.     <bean id="customerManageService"  
  99.         class="com.logcd.business.service.impl.CustomerManageServiceImpl"  
  100.         autowire="byName"/>   
  101.            
  102. </beans>  
<?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" 
	xmlns:tx="http://www.springframework.org/schema/tx" 
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd 
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd 
	http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd 
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

	<description>springApp</description>	
	<!-- dataSource for MySQL -->
	<bean id="dataSource"
		class="org.apache.commons.dbcp.BasicDataSource"
		destroy-method="close">
		<property name="driverClassName"
			value="com.mysql.jdbc.Driver" />
		<property name="url"
			value="jdbc:mysql://localhost:3306/springapp" />
		<property name="username" value="root" />
		<property name="password" value="****" />
	</bean>	

	<!-- Hibernate SessionFactory for MySQL -->
	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />

		<property name="mappingDirectoryLocations">
			<list>
				<value>classpath:/</value>
			</list>
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">
					org.hibernate.dialect.MySQLDialect
				</prop>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.jdbc.fetch_size">50</prop>
				<prop key="hibernate.jdbc.batch_size">100</prop>
			</props>
		</property>

	</bean>


	<!--Transaction --> 
	<bean id="txManager" 
		class="org.springframework.orm.hibernate3.HibernateTransactionManager"> 
			<property name="sessionFactory" ref="sessionFactory" /> 
	</bean> 

	<aop:config> <!--use CGLIB:proxy-target-class="true-->
		<aop:pointcut id="serviceOperator" expression="execution(* com.logcd.business.service.*.*(..))"/>
		<aop:advisor  advice-ref="txAdvice" pointcut-ref="serviceOperator"/> 
		<!--
		<aop:advisor pointcut="execution(* com.logcd.business.service..*Service.*(..))" advice-ref="txAdvice"/>       
		-->
	</aop:config> 
	
	<tx:advice id="txAdvice" transaction-manager="txManager"> 
		<tx:attributes> 
			<tx:method name="find*" read-only="true" /> 
			<tx:method name="load*" read-only="true" /> 
			<tx:method name="is*" read-only="true"/> 
			<tx:method name="save*" 
				rollback-for="Exception"/> 
			<tx:method name="insert*" 
				rollback-for="Exception" /> 
			<tx:method name="remove*"
				rollback-for="Exception"/> 
			<tx:method name="add*"
				no-rollback-for="Exception" /> 
		</tx:attributes> 
	</tx:advice> 
	<!--Transaction --> 
	
	<!-- DAO -->
	<bean id="genericDao" lazy-init="true" abstract="true"
		class="com.logcd.bo.dao.impl.GenericDaoImpl">
		<property name="sessionFactory">
			<ref local="sessionFactory" />
		</property>
	</bean>

	<bean id="customersDao" parent="genericDao"
		class="com.logcd.bo.dao.impl.CustomersDaoImpl" />

	<bean id="customerDao" parent="genericDao"
		class="com.logcd.bo.dao.impl.CustomerDaoImpl" />

	<bean id="addressDao" parent="genericDao"
		class="com.logcd.bo.dao.impl.AddressDaoImpl" />

	<bean id="customerManageService"
		class="com.logcd.business.service.impl.CustomerManageServiceImpl"
		autowire="byName"/>
		
</beans>


(2)测试
Java代码 复制代码
  1. package com.logcd.test;   
  2.   
  3. import org.springframework.context.ApplicationContext;   
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;   
  5.   
  6. import com.logcd.bo.Customers;   
  7. import com.logcd.business.service.CustomerManageService;   
  8.   
  9. import junit.framework.TestCase;   
  10.   
  11. public class SpringServiceTest extends TestCase {   
  12.   
  13.     private CustomerManageService customerManageService;    
  14.        
  15.     protected void setUp() throws Exception {   
  16.         super.setUp();   
  17.         ApplicationContext app = new ClassPathXmlApplicationContext("appContext.xml");   
  18.         customerManageService = (CustomerManageService) app.getBean("customerManageService");   
  19.     }   
  20.   
  21.     protected void tearDown() throws Exception {   
  22.         super.tearDown();   
  23.     }   
  24.   
  25.     public void testService() throws Exception{   
  26.         Customers cus = new Customers();   
  27.         cus.setName("testService");   
  28.         cus.setAge(29);   
  29.         customerManageService.saveCustomers(cus);   
  30.     }   
  31. }  
package com.logcd.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.logcd.bo.Customers;
import com.logcd.business.service.CustomerManageService;

import junit.framework.TestCase;

public class SpringServiceTest extends TestCase {

	private CustomerManageService customerManageService; 
	
	protected void setUp() throws Exception {
		super.setUp();
		ApplicationContext app = new ClassPathXmlApplicationContext("appContext.xml");
		customerManageService = (CustomerManageService) app.getBean("customerManageService");
	}

	protected void tearDown() throws Exception {
		super.tearDown();
	}

	public void testService() throws Exception{
		Customers cus = new Customers();
		cus.setName("testService");
		cus.setAge(29);
		customerManageService.saveCustomers(cus);
	}
}


附：pointcut里的语法
execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?)其中带问号的modifiers-pattern?(public/protected) 和 declaring-type-pattern? throws-pattern? 可以不填

如execution(* *..BookManager.save(..))

第一颗* 代表ret-type-pattern 返回值可任意，
*..BookManager 代表任意Pacakge里的BookManager类。
如果写成com.xyz.service.* 则代表com.xyz.service下的任意类
com.xyz.service..* com.xyz.service则代表com.xyz.service及其子package下的任意类
save代表save方法，也可以写save* 代表saveBook()等方法
(..) 匹配0个参数或者多个参数的，任意类型
(x,..) 第一个参数的类型必须是X
(x,,,s,..) 匹配至少4个参数，第一个参数必须是x类型，第二个和第三个参数可以任意，第四个必须是s类型。
分享到：
| spring使用RMI暴露服务
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    spring1.x使用AOP实例

    最后，Spring 1.x的AOP支持还允许自定义切点表达式，这是通过实现`org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator`类并注册到Spring容器来完成的。这种方式使得基于注解的切面...

    aspectjrt.jar+aspectjweaver.jar+com.springsource.org.aopalliance.jar

    在Spring AOP中，如果使用AspectJ注解或XML配置来定义切面，那么这个库是必不可少的，因为它使得Spring能够理解并执行AspectJ的切面定义。 2. **aspectjweaver.jar**：AspectJ Weaver `aspectjweaver.jar`是...

    @AspectJ配置Spring AOP，demo

    Spring AOP（面向切面编程）是Spring框架的一个重要组成部分，它提供了一种模块化和声明式的方式来处理应用程序中的横切关注点，如日志、事务管理等。在传统的面向对象编程中，这些关注点通常会侵入到业务逻辑中，而...

    Spring开发包含的各种包com.springsource.org.aopalliance-1.0.0.jar

    Spring框架是Java开发中广泛应用的一个开源框架，它以其强大的依赖注入（DI）和面向切面编程（AOP）能力而闻名。"com.springsource.org.aopalliance-1.0.0.jar"是Spring框架的一个关键组件，它包含了AOP Alliance库...

    com.springsource.org.aspectj.weaver-1.6.8.RELEASE 下载

    Spring AOP基于AspectJ提供了一种声明式的AOP支持，使得开发者可以专注于业务逻辑，而无需关心切面的实现细节。 总的来说，AspectJ Weaver 1.6.8.RELEASE作为一个成熟稳定的版本，为Java开发者提供了强大的AOP支持...

    com.springsource.org.aopalliance-1.0.0.jar.zip

    AOP Alliance是由Spring社区创建的一个开源项目，其主要目的是定义一组公共接口，这些接口被各种AOP框架广泛采纳，如Spring AOP和AspectJ。通过这些接口，开发者可以编写与具体AOP实现无关的代码，增加了代码的可...

    Spring框架(6)AspectJ实现AOP共7页.pd

    总之，"Spring框架(6)AspectJ实现AOP共7页.pdf.zip"这份资料详细介绍了如何在Spring中使用AspectJ进行AOP编程，内容涵盖了切面、切点、通知、织入等多个关键概念，对于理解和实践Spring AOP具有很高的参考价值。...

    com.springsource.org.aopalliance-1.0.0的jar包

    Spring框架作为Java EE中的核心组件，提供了丰富的AOP支持，而`aopalliance`库则使得Spring能够与其他AOP框架如AspectJ进行无缝集成。例如，通过使用Spring的`@Aspect`注解定义切面，并结合`@Before`、`@After`等...

    spring-aop-jar

    在Spring AOP中，切面可以通过注解或XML配置来定义。 - 连接点（Join Point）：连接点是程序执行过程中的一个特定点，例如方法的调用或字段的访问。 - 切入点（Pointcut）：切入点是连接点的集合，定义了切面将在...

    AOP.rar-Spring-AOP源码Demo

    Spring AOP，即Aspect-Oriented Programming（面向切面编程），是Spring框架的重要组成部分，它为应用程序提供了一种模块化和声明式的方式来处理横切关注点，如日志、事务管理、性能监控等。在本"Spring-AOP源码Demo...

    Spring 使用AspectJ 实现 AOP

    2. **配置AspectJ**：在Spring的配置文件中启用AspectJ自动代理，可以通过`&lt;aop:aspectj-autoproxy&gt;`标签来实现。 3. **定义切面**：创建一个Java类作为切面，该类需要使用`@Aspect`注解。在切面类中，我们可以定义...

    org.springframework.aop

    在Spring框架中，AOP（Aspect Oriented Programming，面向切面编程）是其核心特性之一，它允许开发者将关注点从主业务逻辑中分离出来，如日志、事务管理等，形成独立的切面，实现代码的解耦和模块化。本篇将深入探讨...

    spring+aspectjweaver-1.7.1.jar+aspectj-1.8.9.jar+aopalliance.jar

    首先，Spring AOP是Spring框架对传统面向对象编程的补充，它主要处理那些分散在应用程序各处的横切关注点，如日志、事务管理、性能监控等。通过AOP，这些关注点可以被模块化为独立的切面，从而提高代码的可读性和可...

    spring和aspectj的aop实验

    其中，类文件可能包含了切面和被通知的对象，配置文件可能包含了Spring和AspectJ的配置，测试用例则用来验证AOP功能是否正常工作。 通过这个实验，你可以深入理解Spring和AspectJ如何协同工作，提升代码的可维护性...

    org.aspectj.lang.annotation.Around所需要的包

    Spring的AOP模块提供了一种声明式的方式来管理横切关注点，如日志记录、事务管理等。它支持四种类型的通知：前置通知（Before）、后置通知（After）、返回通知（After Returning）、异常通知（After Throwing）。...

    Spring 使用AspectJ 实现 AOP之前置通知小例子

    在Spring框架中，AOP（面向切面编程）是一种强大的设计模式，它允许开发者定义“切面”，这些切面封装了关注点，如日志、事务管理或性能度量，从而将它们与业务逻辑分离。AspectJ是Java平台的一个开源项目，提供了...

    Spring4.3.x 源码 可导入Intellij idea

    其次，Spring的AOP特性允许我们定义横切关注点，如日志、事务管理等，这些关注点可以被编织到业务逻辑中，而不必侵入到核心代码。在4.3.x版本中，Spring提供了多种通知类型，包括前置、后置、环绕、异常和最终通知，...

Magicbox
Global site tag (gtag.js) - Google Analytics