`

Spring的AOP配置

aop 
阅读更多
Spring的AOP配置
(2011-04-01 20:38:58)
转载
标签:
spring
aop配置
获取参数
it
分类: SSH框架

1.先写一个普通类:
package com.spring.aop;
public class Common {
public void execute(String username,String password){
     System.out.println("------------------普通类----------------");
   }
}
2.写一个切面类,用于合法性校验和日志添加:
package com.spring.aop;
public class Check {
public void checkValidity(){
     System.out.println("------------------验证合法性----------------");
}
public void addLog(JoinPoint j){
  System.out.println("------------------添加日志----------------");
  Object obj[] = j.getArgs();
   for(Object obj){
    System.out.println(o);
   }
   System.out.println("========checkSecurity=="+j.getSignature().getName());//这个是获得方法名
}
}
3.配置AOP,使用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"
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">
  <bean id="common" class="com.spring.aop.Common"/>
  <bean id="check" class="com.spring.aop.Check"/>
  
  <aop:config>
    <aop:aspect id="myAop" ref="check">
      <aop:pointcut id="target" expression="execution(* com.spring.aop.Common.execute(..))"/>
      <aop:before method="checkValidity" pointcut-ref="target"/>
      <aop:after method="addLog" pointcut-ref="target"/>
    </aop:aspect>
  </aop:config>
</beans>
注意:
execution(* com.spring.aop.*.*(..))"/
这样写应该就可以了
这是com.aptech.jb.epet.dao.hibimpl 包下所有的类的所有方法。。
第一个*代表所有的返回值类型
第二个*代表所有的类
第三个*代表类所有方法
最后一个..代表所有的参数。

4.最后写一个测试:
package com.spring.aop;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Client {
public static void main(String[] args) {
     BeanFactory factory=new ClassPathXmlApplicationContext("applicationContext-aop.xml");
     Common c=(Common) factory.getBean("common");
     c.execute("zhengjunhua","zhengjunhua");
   }
}
注意:
需要添加三个包:spring-aop.jar , aspectjrt.jar ,aspectjweaver.jar,否则会报错。

输出结果:
------------------验证合法性----------------
------------------普通类----------------
------------------添加日志----------------
zhengjunhua
zhengjunhua
========checkSecurity==execute
Spring AOP配置选项
分类: Spring 2010-08-18 15:39 1108人阅读 评论(3) 收藏 举报
Spring实现动态代理配置是有两种配置文件:
1、   xml文件方式;
2、   annotation方式(使用AspectJ类库实现的。)
一、       AOP配置annotation方式
(一)  搭建annotation开发环境
首先:需要在配置文件中加入@AspectJ标签
<aop:aspectj-autoproxy/>
自动帮我产生代理
注意:Spring默认并没有加入aop的xsd文件,因为我们需要手动加入(红色部分)
<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-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/aop
           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
<context:annotation-config/>
<context:component-scan base-package="com.wjt276"/>
<aop:aspectj-autoproxy/>
</beans>

另外需要引用aspectJ的jar包:
aspectjweaver.jar
aspectjrt.jar
(二)  aspectJ类库
AspectJ是一个专门用来实现动态代理(AOP编程)的类库
AspectJ是面向切面编程的框架
Spring使用就是这个类库实现动态代理的
(三)  AOP的annotation实例
要求:在执行save()方法之前加入日志逻辑
1、   spring的配置文件同上面的
2、   model类、dao层类、service层类都与上面天下一致
3、   切面类(LogInterceptor)

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class LogInterceptor {

@Before("execution(public void com.wjt276.dao.impl.UserDaoImpl.save(com.wjt276.model.User))")
public void before(){
System.out.println("method start...");
}
}
结果:这样在运行public void com.wjt276.dao.impl.UserDaoImpl.save(com.wjt276.model.User)方法之前就会先执行这个逻辑了。
注意:
1、@Aspect:意思是这个类为切面类
2、@Componet:因为作为切面类需要Spring管理起来,所以在初始化时就需要将这个类初始化加入Spring的管理;
3、@Befoe:切入点的逻辑(Advice)
4、execution…:切入点语法

(四) 
三个连接点(切入点)
AspectJ的专业术语
1、  JoinPoint
切入面
连接点(切入点)


程序执行过程
 






2、  PointCut
切入点人集合
当需要定义一个切入点时,则需要使用这个
@Pointcut("execution(* com.xyz.someapp.service.*.*(..))")
  public void businessService() {}

3、  Aspect
切面
4、  Advice
切入点的逻辑
例如上例中的@Before
5、  Target
被代理对象
6、  Weave
织入

(五)  织入点语法
1、    无返回值、com.wjt276.dao.impl.UserDaoImpl.save方法 参数为User
execution(public void com.wjt276.dao.impl.UserDaoImpl.save(com.wjt276.model.User))
2、    任何包、任何类、任何返回值、任何方法的任何参数
execution(public * *(..))
3、    任何包、任何类、任何返回值、任何set开头方法的任何参数
execution(* set*(..))
4、    任何返回值、com.xyz.service.AccountService类中的任何方法、任何参数
execution(* com.xyz.service.AccountService.*(..))
5、    任何返回值、com.xyz.service包中任何类中的任何方法、任何参数
execution(* com.xyz.service.*.*(..))
6、    任何返回值、com.xyz.service包中任何层次子包(..)、任何类、任何方法、任何参数
execution(* com.xyz.service..*.*(..))
7、    void 和 !void(非void)
execution(public void com.xyz.service..*.*(..))
execution(public !void com.xyz.service..*.*(..))
注意:上以是AspectJ的织入点语法,Spring AOP也实现了自己的织入点语法,同样可以使用
within(com.xyz.service.*)

within(com.xyz.service..*)

this(com.xyz.service.AccountService)

target(com.xyz.service.AccountService)

args(java.io.Serializable)

@target(org.springframework.transaction.annotation.Transactional)

@within(org.springframework.transaction.annotation.Transactional)

@annotation(org.springframework.transaction.annotation.Transactional)

@args(com.xyz.security.Classified)

bean(tradeService)

bean(*Service)
(六)  Advice
1、     @Before
执行方法之前
@Aspect
public class BeforeExample {
  @Before("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")
  public void doAccessCheck() { // ... }}

@Aspect
public class BeforeExample {
  @Before("execution(* com.xyz.myapp.dao.*.*(..))")
  public void doAccessCheck() { // ... }}
2、     @ AfterReturning
方法正常执行完之后
@Aspect
public class AfterReturningExample {
  @AfterReturning("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")
  public void doAccessCheck() { // ... }}

@Aspect
public class AfterReturningExample {
  @AfterReturning(
    pointcut="com.xyz.myapp.SystemArchitecture.dataAccessOperation()",
    returning="retVal")
  public void doAccessCheck(Object retVal) { // ... }}
3、     @ AfterThrowing
方法抛出异常之后
@Aspect
public class AfterThrowingExample {
  @AfterThrowing("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")
  public void doRecoveryActions() { // ... }}

@Aspect
public class AfterThrowingExample {
  @AfterThrowing(
    pointcut="com.xyz.myapp.SystemArchitecture.dataAccessOperation()",
    throwing="ex")
  public void doRecoveryActions(DataAccessException ex) { // ... }}
4、      @After (finally)
方法抛出异常被catch之后,需要进行的部分(相当于finally功能)
@Aspect
public class AfterFinallyExample {
  @After("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")
  public void doReleaseLock() { // ... }}
5、     @ Around
在方法之前和之后都要加上
但是需要一个参数ProceedingJoinPoint,并者需要Object retVal = pjp.proceed();
和返回return retVal;
@Aspect
public class AroundExample {
  @Around("com.xyz.myapp.SystemArchitecture.businessService()")
  public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {
    // start stopwatch
    Object retVal = pjp.proceed();
    // stop stopwatch
    return retVal; }}

(七)  Pointcut
当多个Advice个有相同的织入点。那么我们可以定义一个织入点集合,在需要使用的地方,调用就可以了。
例如:
@Aspect
@Component
public class LogInterceptor {

@Pointcut("execution(public * com.wjt276.dao..*.*(..))")
public void myMethod(){};

@Before(value="myMethod()")
public void before(){
System.out.println("method start...");
}

@AfterReturning("myMethod()")
public void afterReturning(){
System.out.println("method after returning...");
}}
注意:那个空方法,只是为了给Pointcut起个名字,以方便别处使用

(八)    annotatin方式的AOP实例
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
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 {

@Pointcut("execution(public * com.wjt276.dao..*.*(..))")
public void myMethod(){};

@Before(value="myMethod()")
public void before(){
System.out.println("method start...");
}

@AfterReturning("myMethod()")
public void afterReturning(){
System.out.println("method after returning...");
}

@Around(value="myMethod()")
public void around(ProceedingJoinPoint pjp) throws Throwable{
//因为@around需要传入一个参数ProceedingJoinPoint进行前后加逻辑
System.out.println("method around start...");

//在需要前后逻辑的中间加入下列语句。表示前后逻辑,可能会抛出异常Throwable。
pjp.proceed();
System.out.println("method around end...");
}
}

二、       AOP配置xml方式
xml方式是我们以后使用的比较多的,因为当切面类我们没有源代码时、当我们使用第三方的切面类时,我就不能使用annotation的方式,而且如果使用annotation方式一但程序编译后就不可以修改了。如果使用xml方式就不一样了,我们只需要修改xml文件就可以了。
xml方式与annotation的作用是一样。现在就是实例:
<?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-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/aop
           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
<context:annotation-config/>
<context:component-scan base-package="com.wjt276"/>
<bean id="logInterceptor" class="com.wjt276.aop.LogInterceptor"></bean>
<aop:config>
<!-- <aop:pointcut >在此处定义的pointcut是全局的pointcut可以供所有的aspect使用
id:表示这个pointcut的名称,以方便使用-->
<aop:pointcut id="myMethod"
  expression="execution(public * com.wjt276.service..*.*(..))" />
<!--  <aop:aspect>表示定义一个切面类(这需要Spring初始化加入其管理)
id:切面类的名称,
ref:引用哪个bean(需要使用<bean>标签初始化)-->
<aop:aspect id="logAspect" ref="logInterceptor">
<!-- 在此处定义的pointcut是全局的pointcut只供当前的aspect使用
id:表示这个pointcut的名称,以方便使用 -->
<aop:pointcut id="myMethod2"
  expression="execution(public * com.wjt276.service..*.*(..))" />
<!--
定义advice时的参数
method:切面逻辑的方法名称(切面类中的方法名)
pointcut-ref:表示引用哪个pointcut(要求已经在上面定义好了)
pointcut:定义一个pointcut -->
<aop:before method="before" pointcut-ref="myMethod"/>
<aop:after-returning method="afterReturning" pointcut="execution(public * com.wjt276.service..*.*(..))"/>
</aop:aspect>
</aop:config>
</beans>


三、       AOP实现动态代理注意
因为Spring要实现AOP(面向切面编程),需要加入切面逻辑的类就会生成动态代理。在动态代理类中加入切面类从而实现面向切面编程,但生成动态代理存在以下注意事项:
1、   被动态代理的类如果实现了某一个接口,那么Spring就会利用JDK类库生成动态代理。
2、   如果被动态代理的类没有实现某一个接口,那么Spring就会利用CGLIB类库直接修改二进制码来生成动态代理(因为利用JDK生成动态代理的类必须实现一个接口),需要在项目中引用CGLIB类库

分享到:
评论

相关推荐

    springAop的配置实现

    在Spring XML配置文件中,我们可以定义以下元素来实现AOP配置: - `&lt;aop:config&gt;`:声明AOP配置。 - `&lt;aop:pointcut&gt;`:定义切入点表达式,例如`execution(* com.example.service.*.*(..))`表示匹配...

    Spring AOP配置事务方法

    Spring AOP 配置事务方法 Spring AOP(Aspect-Oriented Programming,面向方面编程)是一种编程范式,它允许开发者在不修改源代码的情况下,增强和修改应用程序的行为。 Spring AOP 提供了一种灵活的方式来实现事务...

    使用Spring配置文件实现AOP

    以下是一个简单的Spring AOP配置文件示例: ```xml &lt;aop:config&gt; &lt;aop:aspect id="loggingAspect" ref="loggingAdvice"&gt; &lt;aop:before method="beforeMethod" pointcut-ref="businessMethods"/&gt; &lt;aop:after-...

    Spring AOP配置实例

    **Spring AOP配置实例** Spring AOP(Aspect Oriented Programming,面向切面编程)是Spring框架的核心组件之一,它提供了一种在不修改源代码的情况下,对程序进行功能增强的技术。AOP允许开发者定义“切面”,这些...

    Spring之AOP配置文件详解

    ### Spring之AOP配置文件详解 #### 一、前言 在Java开发中,Spring框架因其强大的功能和灵活的配置而被广泛应用于企业级应用的开发。其中,面向切面编程(Aspect Oriented Programming,简称AOP)是Spring框架的...

    利用SPring AOP配置切面的一个例子

    本例中,我们关注的是如何利用Spring AOP配置一个简单的切面,该切面在`DukePerformer`类的`perform`方法执行前后,插入观众的行为,如找座位、关手机、鼓掌以及不满意的反应。通过这种方式,我们将这些行为抽象为...

    spring AOP配置的几种方式

    ### Spring AOP配置详解 #### 一、Spring AOP配置概览 面向切面编程(Aspect-Oriented Programming,简称AOP)是Spring框架的重要特性之一,它通过将业务逻辑中的横切关注点(Cross-cutting Concerns)与核心业务...

    springAOP配置动态代理实现

    2. **注解配置**:Spring 2.5引入了基于注解的AOP配置,可以在切面类上使用@Aspect注解,@Before、@After、@AfterReturning、@AfterThrowing和@Around定义通知,@Pointcut定义切点。例如: ```java @Aspect ...

    Spring AOP配置与管理

    **Spring AOP配置与管理** 在Java开发中,Spring框架以其强大的功能和灵活性深受开发者喜爱。其中,AOP(Aspect-Oriented Programming,面向切面编程)是Spring框架的一个重要特性,它允许开发者定义“切面”,即...

    Spring AOP 配置小节

    **Spring AOP 配置小节** 在Java开发中,Spring框架因其强大的功能和灵活性而备受推崇,其中AOP(面向切面编程)是其重要特性之一。AOP允许我们把关注点分离到非核心业务逻辑之外,如日志、事务管理等,使得代码...

    spring aop配置

    ### Spring AOP配置详解 #### 一、Spring AOP简介 Spring AOP(Aspect Oriented Programming,面向切面编程)是Spring框架中的一个重要模块,它提供了强大的AOP功能支持。AOP是一种编程范式,旨在将横切关注点(如...

    Spring AOP配置

    Spring AOP 配置 Spring AOP(Aspect-Oriented Programming)是一种面向方面编程技术,通过将关注点模块化,提高了系统的可维护性和可扩展性。下面将详细介绍 Spring AOP 的配置和实现。 一、基本概念 * 切面...

    Spring aop 配置

    Spring aop 配置 Spring aspect 配置 Spring advisor 配置 Spring pointcut 配置

    Spring AOP实现机制

    Spring AOP配置 Spring AOP的配置可以通过XML或注解方式进行: - **XML配置**: - 在`&lt;aop:config&gt;`标签内定义切面,`&lt;aop:pointcut&gt;`定义切入点,`&lt;aop:advisor&gt;`定义通知。 - `&lt;aop:aspect&gt;`标签用于定义完整...

    spring aop配置常用jar包

    2. **配置Spring容器**:在Spring的XML配置文件中启用AOP支持,通过`&lt;aop:config&gt;`标签开启,并可以定义切点(pointcut)和通知(advice)。 3. **定义切点**:使用`&lt;aop:pointcut&gt;`定义要拦截的方法或类。切点...

    spring aop jar 包

    在使用Spring AOP时,我们可以通过XML配置或注解的方式来定义切面。例如,可以使用`@Aspect`注解定义一个切面类,`@Before`、`@After`等注解来声明通知,`@Pointcut`定义切点表达式。 在实际开发中,Spring AOP广泛...

    Spring Aop使用实例

    Spring AOP配置 在Spring XML配置文件中,可以声明切面和通知,如下: ```xml &lt;aop:config&gt; &lt;aop:aspect id="loggingAspect" ref="loggingService"&gt; &lt;aop:before method="logBefore" pointcut="execution(* ...

    spring aop 附带测试实例

    在提供的压缩包文件"springAOP"中,可能包含了以下内容: - **切面类(Aspect Class)**:包含切点和通知的Java类,可能使用了`@Aspect`注解。 - **目标类(Target Class)**:被AOP代理的对象,通常包含业务逻辑。...

Global site tag (gtag.js) - Google Analytics