`

spring_aop模板

阅读更多
applicationContext.xml文件如下:
<?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"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="
http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/aop 
http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
  http://www.springframework.org/schema/context   
   http://www.springframework.org/schema/context/spring-context-2.5.xsd
">


	<aop:aspectj-autoproxy /> <!-- 支持注解方式 -->
	
	
	<context:component-scan  base-package="com.bjsxt"/>
	
</beans>

-----------------------------------------------------------
   常用切面编程的模板文件用时拷贝一下:
package com.bjsxt.test.spring.aop;

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;

/**
 * 日志拦截器
 */
@Aspect
@Component
public class LogInterceptor {

//	public User add(User user)
//	@Pointcut("execution(public  *  com.bjsxt.test.spring.aop.*.add*(..))")
	
	@Pointcut("execution(public  *  com.bjsxt.test.spring.aop.*.get*(..))")  //声明一个名字为log的切入点
	private void log(){//如果其他的地方要引用这个切入点,,就写这个方法名
	}
	
	
	@Before("log()"+"&&args(user)")   //使用pointcut-->log .前置通知.处理传入的参数跟下面的形参保持一致即可。
	private void before(User user){
		System.out.println("方法执行前:"+user.getUname());
		System.out.println("方法执行前!");
	}
	
	@After("log()")   //最终后置通知。不管有无异常,最终都会执行!
	private void after(){
		System.out.println("方法执行后!");
	}

	@AfterReturning("log()")  //方法正常结束,后置通知
	private void afterReturning(){
		System.out.println("方法执行后!after returning!");
	}

	@AfterThrowing("log()")    //抛出异常会执行,异常通知
	private void afterThrowing(){
		System.out.println("方法执行后!after throwing!");
	}
	
	
	@Around("log()")   //环绕通知在一个方法执行之前和之后执行
	private Object around(ProceedingJoinPoint pjp){
		System.out.println("环绕通知,方法执行前!");
		Object obj = null;
		try {
			obj = pjp.proceed();//出调用真正的方法
		} catch (Throwable e) {
			e.printStackTrace();
		}
		System.out.println("环绕通知,方法执行后!");
		return obj;
	}
	
}


源文件下载地址:http://pan.baidu.com/share/link?shareid=1804614721&uk=1057836303
----------------------------------下面是配置文件方式实现切面编程
<?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"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
		http://www.springframework.org/schema/aop 
		http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
		http://www.springframework.org/schema/context   
		http://www.springframework.org/schema/context/spring-context-2.5.xsd
">

	<aop:aspectj-autoproxy /> <!-- 支持注解方式 -->
	<context:component-scan  base-package="com.bjsxt"/>
	
	<!-- 采用配置方式使用AOP -->
	<bean id="logInterceptor" class="com.bjsxt.spring.aop.LogInterceptor"></bean>
	
	<aop:config >
		<!--定义切点 名字log  -->
		<aop:pointcut expression="execution(public !java.lang.String com.bjsxt.spring.aop.UserDaoImpl.*(com.bjsxt.spring.aop.User,..))" id="log"/>
		
		<!-- 定义切面   logAspect-->
		<aop:aspect id="logAspect" ref="logInterceptor">
		
		<!-- 定义前置通知  -->
		<!-- arg-names="user,age,name,test" 多参数   arg-names 指定before参数名   -->
		  	<aop:before method="before" arg-names="user" pointcut="execution(!java.lang.String com.bjsxt.spring.aop.UserDaoImpl.add(..)) and args(user)" />
		  <!-- 后置通知 -->
			<aop:after method="after"  pointcut-ref="log" />
			
			<aop:after-throwing method="afterThrowing" pointcut-ref="log"/>
			
			<aop:after-returning method="afterReturning" pointcut-ref="log"/>
			
			<aop:around method="around"  pointcut-ref="log"/>
		</aop:aspect>
		 
		
	</aop:config>
	
</beans>

----------------------------------------------
package com.bjsxt.spring.aop;

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;

/**
 * 日志拦截器
 */


public class LogInterceptor {

//	@Pointcut("execution(!java.lang.String com.cssxt.spring.aop.UserDaoImpl.add(com.cssxt.spring.aop.User,..))")  //生命一个名字为log的切入点
	private void log(){
	}
	
//	@Before("log()"+"&&args(user)")   //使用pointcut-->log .前置通知.处理传入的参数跟下面的形参保持一致即可。
	private void before(User user){
		System.out.println("方法执行前:"+user.getUname());
		System.out.println("方法执行前!");
	}
	
//	@After("log()")   //最终后置通知。不管有无异常,最终都会执行!
	private void after(){
		System.out.println("方法执行后!");
	}

//	@AfterReturning("log()")  //方法正常结束,后置通知
	private void afterReturning(){
		System.out.println("方法执行后!after returning!");
	}

//	@AfterThrowing("log()")    //抛出异常会执行,异常通知
	private void afterThrowing(){
		System.out.println("方法执行后!after throwing!");
	}
	
	
//	@Around("log()")   //环绕通知在一个方法执行之前和之后执行
	private Object around(ProceedingJoinPoint pjp){
		System.out.println("环绕通知,方法执行前!");
		Object obj = null;
		try {
			obj = pjp.proceed();
		} catch (Throwable e) {
			e.printStackTrace();
		}
		System.out.println("环绕通知,方法执行后!");
		return obj;
	}
	
}
分享到:
评论

相关推荐

    spring_aop.rar_spring-dao

    3. `MyDaoImpl.java`:DAO接口的实现类,使用Spring提供的模板方法来执行SQL。 4. `MyService.java`:业务逻辑服务类,通过@Autowired注解注入DAO实例,调用DAO方法进行数据操作。 5. `MyAspect.java`:AOP切面类,...

    Spring_jdbc模板相关jar包

    通过AOP(面向切面编程)和DAO(数据访问对象)模式,Spring可以统一处理事务控制和异常转换,使代码更加简洁、易读。 总的来说,"Spring_jdbc模板相关jar包"是开发基于Spring的Java应用时处理数据库操作的关键组件...

    Spring_2000_Spring_Hibernate_HibernateTemplate

    Spring的主要特性包括依赖注入(DI)、面向切面编程(AOP)、容器管理的bean以及对其他框架的集成,比如与Hibernate的整合。 **依赖注入(DI)** Spring的核心之一是依赖注入,它允许对象在运行时通过容器获得所需...

    spring_hibernate_aop:关于Spring MVC,Hibernate,AOP,Spring Security的Udemy课程

    【标题】"spring_hibernate_aop"所涉及的是一个关于Spring MVC、Hibernate、AOP(面向切面编程)以及Spring Security的在线课程,这四个技术是Java开发领域中非常核心的部分,尤其在企业级应用开发中广泛应用。...

    struts2_spring_ibatis根据模板文件导出Excel

    Spring框架则是用来管理依赖注入(DI)和控制反转(IOC),同时提供了AOP(面向切面编程)支持,方便我们进行事务管理和权限控制。在这个场景下,Spring可以用来管理Struts2中的Action实例,以及与iBatis的整合,...

    Eclipse_Spring_入门书籍

    4. **数据访问集成**:介绍Spring与数据库的交互,如JDBC模板、Hibernate和MyBatis的整合。 5. **Spring MVC**:学习如何构建基于Spring MVC的Web应用,包括控制器、视图解析、模型数据和请求处理。 6. **Spring...

    struts2_spring_mybatis

    此外,Spring还提供了对数据库操作的支持,如JDBC模板和ORM集成,以及对其他框架的集成功能,如与Struts2和MyBatis的整合。 2. **Struts2框架**:Struts2是基于MVC设计模式的Web开发框架,它负责处理HTTP请求并将其...

    BLOG.rar_blog_spring_spring blog_struts

    之后,Spring MVC将结果呈现到视图层,通常使用模板引擎如Thymeleaf或FreeMarker。视图层可以展示博客文章、评论、用户信息等。 **3. Struts框架** Struts是Apache组织下的一个MVC框架,它基于Model 2架构,为Java ...

    Test07_Spring_Web_XML.rar

    总结起来,“Test07_Spring_Web_XML.rar”是一个基础的Spring MVC工程模板,包含了Maven构建、基础配置和核心组件的设置,为开发者提供了一个起点,方便他们在此基础上添加自己的业务逻辑和功能。理解这些知识点对于...

    BBS.rar_bbs论坛spring_hibernate_spring bbs_struts hibernate bbs_论坛

    2. **Spring框架**:Spring是一个全面的企业级应用框架,提供了DI(Dependency Injection)和AOP(Aspect-Oriented Programming)功能。DI允许开发者解耦组件,提高代码的可测试性和灵活性;AOP则允许定义横切关注点...

    spring-framework-4.0.6.RELEASE

    其次,4.0.6.RELEASE版本在模块化设计上更进一步,将核心容器(Core Container)、数据访问/集成(Data Access/Integration)、Web、AOP(面向切面编程)和测试等模块进行了明确划分,有助于开发者根据项目需求选择...

    Spring AOP IOC源码笔记.pdf

    JdbcTemplate是Spring提供的一个简单易用的数据库操作工具,通过模板方法模式封装了JDBC的常用操作,减少了数据库访问的复杂性,同时保持了事务管理能力。 10. Spring AOP API: Spring AOP提供了Pointcut、Advisor...

    spring_in_action_source.

    4. **数据访问**:Spring提供了多种数据访问支持,如JDBC模板、ORM集成(如Hibernate、MyBatis),以及对NoSQL数据库的支持。它简化了数据库操作,提供了事务管理策略,提高了开发效率。 5. **MVC框架**:Spring ...

    Spring_2.0.rar

    2. **AOP**:Spring 2.0在AOP方面做了重大改进,提供了更强大的切面定义和通知类型,如前置通知、后置通知、环绕通知等。这使得我们可以更好地实现日志记录、事务管理、安全控制等功能,而不必侵入业务逻辑。 3. **...

    设计模式之动态代理与spring的aop编程

    动态代理和Spring AOP(面向切面编程)是两个关键的设计概念,它们在实现高效、模块化的系统中起着至关重要的作用。本文将深入探讨这两个概念,并结合实际应用进行解析。 首先,让我们理解什么是动态代理。动态代理...

    ssmbuild_springmvc_spring_bootstrap_mybatis_

    此外,Spring还提供了事务管理、AOP(面向切面编程)等功能,使得业务逻辑的编写更为简洁。 MyBatis是一个持久层框架,它简化了数据库操作。开发者可以将SQL语句写在XML配置文件或者注解中,与Java对象映射,从而...

    spring_jar包源码包

    这个版本包含了Spring的核心模块,例如Spring Core、Spring Beans、Spring Context、Spring AOP、Spring JDBC、Spring ORM等。这些模块分别负责基础依赖注入、上下文管理、面向切面编程、数据库操作以及对象/关系...

    spring_springmvc_mybatis_shiro

    Spring是Java企业级应用的核心框架,它提供了依赖注入(DI)和面向切面编程(AOP)等特性,极大地简化了Java开发。Spring还包含对其他技术的集成,如数据访问、事务管理、邮件服务、任务调度等。在本项目中,Spring...

    spring-framework-master_spring_Framework_

    4. **Spring MVC**:作为Web模块的一部分,Spring MVC是处理HTTP请求的优秀框架,支持RESTful API、模板引擎、数据绑定等特性,使得Web应用开发更高效。 5. **Spring Boot**:虽然不在当前压缩包中,但Spring Boot...

Global site tag (gtag.js) - Google Analytics