`
beyond429
  • 浏览: 95417 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

spring aop 2.0 编程

阅读更多
原文:http://www.blogjava.net/zyl/archive/2006/09/17/70116.html

一个很好理解的aop 例子,也就是日志服务。
先从aop第一种方式来实现,也就是xml配置方式
先创建基本的日志类:
public class Logger {

    private static Log log = LogFactory.getLog(Logger.class);

    public void entry(String message) {
        log.info(message);
    }
}
这里只是简单的一个方法,当然实际情况可能不同。
由于xml配置需要一个方面的实现bean
所以创建一个简单的bean :
public class LogBean {

    private Logger logger = new Logger();

    public Object aroundLogCalls(ProceedingJoinPoint joinPoint) throws Throwable {
        logger.entry("before invoke method:"
                     + joinPoint.getSignature().getName());
        Object object = joinPoint.proceed();
        logger.entry("after invoke method:"
                     + joinPoint.getSignature().getName());
        return object;
    }
}
这里采取简单的around advice,其他类型的advice 基本上都差不多

当然有了这两个核心的日志类,需要一个测试类,用于测试。
public class TestBean {

    public void method1() {
        System.out.println("in method1");
    }

    public void method2() {
        System.out.println("in method2");
    }
}
这就是需要测试的类了,需要记录日志的方法只有两个,这里用System.out.println,只是想显示方法的调用顺序。


然后关键的在于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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd">

<aop:config>
    <!--  expression 表示要执行的匹配表达式,这里匹配所有的public方法,但是去除logger类的所有方法,防止无限调用-->

      <aop:pointcut id="loggableCalls"
          expression="execution(public * *(..)) and !execution(* org.spring.test.aop.log.Logger.*(..))"/>


  <aop:aspect id="logAspect" ref="logBean">
   <aop:around pointcut-ref="loggableCalls" method="aroundLogCalls"/>
  </aop:aspect>

</aop:config>
<bean id="logBean" class="org.spring.test.aop.log.LogBean" />
<bean id="testBean" class="org.spring.test.aop.log.TestBean"/>

</beans>

现在写一个测试类:

public class LogXmlTest extends RootTest {

    @Override
    protected String getBeanXml() {
        return "org/spring/test/aop/log/bean.xml";
    }

    public void testLog() {
        TestBean bean = (TestBean) ctx.getBean("testBean");
        bean.method1();
        bean.method2();
    }

}

public abstract class RootTest extends TestCase {

    protected ApplicationContext  ctx;

    protected Log log = LogFactory.getLog(getClass());

    protected RootTest() {
        ctx = new ClassPathXmlApplicationContext(getBeanXml());
    }

    protected abstract String getBeanXml();

}

打印的消息如下:
2006-09-17 11:08:28,203 INFO [org.spring.test.aop.log.Logger] - before invoke method:method1
in method1
2006-09-17 11:08:28,203 INFO [org.spring.test.aop.log.Logger] - after invoke method:method1
2006-09-17 11:08:28,218 INFO [org.spring.test.aop.log.Logger] - before invoke method:method2
in method2
2006-09-17 11:08:28,218 INFO [org.spring.test.aop.log.Logger] - after invoke method:method2

第二种实现方式,采用注释方式:

Logger 类不变
创建一个LogAspect类
@Aspect
public class LogAspect {

    private Logger logger = new Logger();

    @Pointcut("execution(public * *(..))")
    public void publicMethods() {

    }

    @Pointcut("execution(* org.spring.test.aop.log.Logger.*(..))")
    public void logObjectCalls() {

    }

    @Pointcut("publicMethods()&&!logObjectCalls()")
    public void loggableCalls() {

    }

    @Around("loggableCalls()")
    public Object aroundLogCalls(ProceedingJoinPoint joinPoint) throws Throwable {
        logger.entry("before invoke method:"
                     + joinPoint.getSignature().getName());
        Object object = joinPoint.proceed();
        logger.entry("after invoke method:"
                     + joinPoint.getSignature().getName());
        return object;
    }
}

配置文件就简单多了
<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd">

<aop:aspectj-autoproxy/>

<!-- 或者使用以下定义



<bean class="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator" />

-->
<bean id="logAspect" class="org.spring.test.aop.log.LogAspect"/>
<bean id="testBean" class="org.spring.test.aop.log.TestBean"/>

</beans>

测试类:
跟上面的差不多
把xml文件换掉就行

打印的方式差不多

个人还是比较喜欢第二种实现。
分享到:
评论

相关推荐

    Spring AOP 2.0 研究

    **Spring AOP 2.0 研究** 在软件开发中,面向切面编程(Aspect-Oriented Programming,简称AOP)是一种重要的设计模式,它允许开发者将关注点从核心业务逻辑中分离出来,例如日志记录、事务管理、性能监控等。...

    spring framework 2.0 中文参考手册

    Spring作为一个开源的轻量级框架,旨在简化企业级应用的开发,通过依赖注入(Dependency Injection,DI)和面向切面编程(Aspect-Oriented Programming,AOP)等核心特性,极大地提高了代码的可测试性和可维护性。...

    spring framework 2.0 dist 资源文件

    另外,Spring 2.0引入了AOP(面向切面编程)概念,允许开发者定义横切关注点,如日志、事务管理等,将其与业务逻辑分离,提高了代码的可读性和可维护性。Spring AOP支持基于注解的切面定义,以及自定义通知类型,...

    Spring_2.0.rar

    Spring框架以其依赖注入(Dependency Injection,DI)和面向切面编程(Aspect-Oriented Programming,AOP)为核心理念,旨在简化Java应用程序的开发和维护。在2.0版本中,这些概念得到了进一步强化和完善。 1. **...

    Spring Framework 2.0开发参考手册(中文版chm)

    Spring作为一个轻量级、全面的企业级应用框架,为Java开发提供了强大的支持,尤其在依赖注入(Dependency Injection,DI)、面向切面编程(Aspect-Oriented Programming,AOP)以及数据访问集成方面表现卓越。...

    springframework2.0

    2. **AOP(面向切面编程)**:Spring的AOP模块允许开发者定义和执行横切关注点,如日志记录、事务管理等,从而分离核心业务逻辑。Spring 2.0增强了对AOP的支持,添加了注解驱动的AOP,使得无需XML配置即可创建切面。...

    spring-framework-2.0

    2. **AOP(Aspect-Oriented Programming, 面向切面编程)**:Spring 2.0提供了增强的AOP支持,包括自定义注解,可以创建可重用的横切关注点,如事务管理、日志记录等,使代码更清晰,职责划分更明确。 3. **数据...

    Spring-Security2.0 和 3.0中文文档

    6. **AOP(面向切面编程)安全**: 2.0 和 3.0 都支持AOP,可以对方法级别的安全进行控制。通过@Secured、@PreAuthorize和@PostAuthorize等注解,可以在方法上添加安全约束。 7. **Web表单认证**: 两个版本都...

    spring2.0 核心jar包

    2. **AOP(面向切面编程)**:Spring2.0引入了全面的AOP支持,允许开发者定义和执行横切关注点,如日志、事务管理等,从而实现代码的模块化,提高代码的复用性和可维护性。 3. **IoC容器增强**:在Spring2.0中,IoC...

    Spring2.0中文教程

    Spring 2.0支持面向切面编程,允许开发者定义横切关注点,如日志、事务管理和安全性,作为可重用的模块。AOP通过切点(pointcut)和通知(advice)实现,使得代码更加模块化,降低了复杂性。 3. **IoC容器** ...

    spring-framework-2.0 Java源代码,spring2源代码

    2. **AOP(面向切面编程)**:Spring 2.0提供了基于代理的AOP实现,允许开发者定义切面,实现跨切面的关注点,如日志、事务管理等。AOP使得这些通用功能的实现变得更加简洁,降低了代码的重复性。 3. **Bean工厂与...

    Spring2.0宝典源代码

    1. **AOP(面向切面编程)增强**:Spring 2.0加强了对AOP的支持,允许开发者定义更复杂的切面,如注解驱动的切面,提供了更多的通知类型,如around、before、after等,使得代码更加模块化和可维护。 2. **注解驱动...

    Spring Security 2.0.x完全中文参考文档

    ### Spring Security 2.0.x完全中文参考文档 #### 序言 本文档旨在为用户提供一份详尽且全面的Spring Security 2.0.x版本的中文指南,它不仅覆盖了核心概念、配置方法以及实际应用案例,还深入探讨了安全框架的...

    SPRING2.0中文文档

    Spring 2.0的AOP增强了切入点表达式,使得定位切点更加灵活,并引入了基于注解的切面定义,让切面编写更加直观。 四、数据访问集成 Spring 2.0在数据访问层提供了对各种持久化技术的集成,包括JDBC、ORM(Hibernate...

    spring2.0中文手册及使用指南 chm

    Spring 2.0 是一个非常重要的Java框架,它在企业级应用开发中占据了核心地位,尤其是在基于Java的轻量级应用程序上下文(IoC)和面向切面编程(AOP)方面。本手册和使用指南提供了全面的Spring 2.0相关知识,包括其...

    spring2.0_jar

    这个压缩包包含了一系列Spring框架的核心组件和其他相关库,使得开发者能够轻松地实现依赖注入、面向切面编程(AOP)以及数据库操作等功能。下面我们将逐一探讨这些jar包的功能和它们在Spring 2.0中的作用。 1. ...

    Spring2.0整合Struts2.0

    Spring以其强大的依赖注入(DI)和面向切面编程(AOP)能力而闻名,而Struts2则是一款优秀的MVC框架,提供了良好的动作(Action)管理和结果映射功能。当我们需要构建复杂的企业级应用时,将两者整合能充分发挥它们...

    Spring_2.0_Samples

    AOP(Aspect-Oriented Programming,面向切面编程)是Spring的另一大特色。它允许我们定义关注点(如日志、事务管理等)并将其模块化,独立于业务逻辑之外。Spring AOP支持使用注解定义切面,如`@Before`、`@After`...

Global site tag (gtag.js) - Google Analytics