`

Spring 面向切面(Java)

 
阅读更多

Maven配置文件

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.jinglun</groupId>
  <artifactId>SpringInAction</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>SpringInAction Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <!-- Spring集成Junit-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-core</artifactId>
        <version>3.1.0</version>
        <scope>test</scope>
    </dependency>
    
    <!-- Spring Aop -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.4</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>1.6.11</version>
    </dependency>
    
    <!-- Spring MVC -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>4.3.2.RELEASE</version>
    </dependency>
    <!-- Spring Core -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>4.3.2.RELEASE</version>
    </dependency>
    <!-- junit -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
  </dependencies>
  <build>
    <finalName>SpringInAction</finalName>
  </build>
</project>

 

通知类

Audience.java

package concert;

import org.aspectj.lang.ProceedingJoinPoint;
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;

@Aspect
public class Audience {
    
    @Pointcut("execution(** concert.Performance.perform(..))")
    public void performance() {}
    
    @Before("performance()")
    public void silenceCellPhones() {
        System.out.println("Silencing cell phones");
    }
    
    @Before("performance()")
    public void takeSeats() {
        System.out.println("Taking seats");
    }
    
    @AfterReturning("performance()")
    public void applause() {
        System.out.println("CLAP CLAP CLAP!!!");
    }
    
    @AfterThrowing("performance()")
    public void demandRefund() {
        System.out.println("Demanding a refund");
    }

    @Around("performance()")
    public void watchPerformance(ProceedingJoinPoint jp) {
        try {
            System.out.println("Silencing cell phones");
            System.out.println("Taking seats");
            jp.proceed();
            System.out.println("CLAP CLAP CLAP!!!");
        } catch (Throwable e) {
            System.out.println("Demanding a refund");
        }
    }
}

 

配置文件

ConcertConfig.java

package concert;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy
@ComponentScan
public class ConcertConfig {

    @Bean
    public Audience audience() {
        return new Audience();
    }

    @Bean
    public Performance perform() {
        return new PerformanceImpl();
    }
}

 

切点

Performance.java

package concert;

public interface Performance {
    public void perform();
}

 

 

PerformanceImpl.java

package concert;

import org.springframework.stereotype.Component;

@Component
public class PerformanceImpl implements Performance{

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

 

测试类

PerformTest.java

package concert;

import static org.junit.Assert.assertNotNull;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import concert.ConcertConfig;
import concert.Performance;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes=ConcertConfig.class)
public class PerformTest {
    
    @Autowired
    private Performance perform;
    
    @Test
    public void play() {
        perform.perform();
        assertNotNull(perform);
    }
}

 

分享到:
评论

相关推荐

    Spring面向切面编程AOP

    面向切面编程(AOP,Aspect Oriented Programming)是Spring框架中的一个重要特性,它提供了一种模块化和声明式的方式来处理程序中的横切关注点,如日志、事务管理、安全控制等。AOP的核心概念包括切面、通知、连接...

    Spring Aop面向切面的java代码

    Spring AOP,全称Spring面向切面编程,是Spring框架中的一个重要组成部分,它提供了一种在不修改原有代码的情况下,对程序进行功能增强的技术。面向切面编程(Aspect Oriented Programming,AOP)的核心思想是将关注...

    Spring AOP面向切面三种实现

    在IT行业中,Spring框架是Java企业级应用开发的首选,其强大的功能之一就是AOP(面向切面编程)。本文将详细解析Spring AOP的三种实现方式,帮助你深入理解这一重要概念。 首先,理解AOP的基本概念至关重要。AOP是...

    Spring面向切面编程示例代码

    面向切面编程(Aspect-Oriented Programming,AOP)是Spring框架的核心特性之一,它提供了一种模块化和声明式的方式来处理系统中的横切关注点,如日志、事务管理、安全检查等。本示例代码主要展示了如何在Spring框架...

    spring使用动态代理面向切面编程(AOP) xml

    在Spring框架中,面向切面编程(AOP)是一种强大的设计模式,它允许开发者将关注点分离,将横切关注点(如日志、事务管理、权限检查等)与核心业务逻辑解耦。本篇文章将深入探讨如何使用Spring的动态代理机制实现AOP...

    AOP_使用spring框架进行面向切面编程

    面向切面编程(AOP)是一种编程范式,它旨在减少代码中的重复部分,特别是那些与核心业务逻辑无关但又必须处理的交叉关注点,如日志、事务管理、安全控制等。Spring框架是Java领域中实现AOP的常用工具,它通过提供...

    JAVA Spring AOP面向切面编程笔记

    JAVA Spring AOP面向切面编程笔记

    Spring-aop面向切面编程实例

    面向切面编程(Aspect-Oriented Programming,AOP)是Spring框架的核心特性之一,它提供了一种优雅的方式来处理系统的横切关注点,如日志、事务管理、性能监控和权限控制等。在Spring中,AOP主要通过代理模式实现,...

    面向切面编程 动态代理的经典例子

    面向切面编程(AOP,Aspect Oriented Programming)是一种编程范式,旨在将关注点分离,使得业务逻辑和系统服务(如日志、事务管理、权限控制等)能够解耦。这种编程方式允许程序员定义“切面”,这些切面封装了特定...

    Spring-AOP java2ee中的Spring框架的面向切面示例

    在Java企业级开发中,Spring框架是一个不可或缺的重要组件,它为开发者提供了丰富的功能,包括依赖注入、面向切面编程(AOP)、数据访问/集成、Web应用、事务管理等。本示例主要聚焦于Spring框架的面向切面编程(AOP...

    Java Spring AOP 面向切面编程的4种实现

    Spring AOP (面向切面编程框架): Spring框架内建了支持动态代理的功能,使用@AspectJ注解可以轻松地创建AOP代理。Spring AOP既支持JDK动态代理也支持CGLIB,会根据目标类是否实现了接口选择合适的底层技术。 Guice ...

    Spring4AOP 面向切面编程实例之方法拦截

    Spring4AOP 面向切面编程实例之方法拦截实例 一下利用Spring4的最后一个版本Spring4.3.9,实现简单的方法拦截实例。 Eclipse 建立java工程,导入必要的jar包,工程目录如下:

    spring aop 自定义切面示例

    在Spring AOP(面向切面编程)中,自定义切面是实现业务逻辑解耦、增强代码可维护性的重要手段。AspectJ是一个强大的面向切面的编程库,它提供了与Spring AOP集成的能力,使我们可以编写更为灵活和模块化的代码。...

    spring切面AOP所使用的jar包

    Spring框架的AOP(面向切面编程)是其核心特性之一,它允许开发者在不修改原有代码的情况下,通过切面来插入额外的功能,比如日志记录、事务管理、性能监控等。在Spring AOP中,主要涉及到两个重要的库:...

    java面向切面编程

    面向切面编程(AOP,Aspect Oriented Programming)是Java编程中的一种重要概念,它旨在提高代码的可重用性和可维护性。AOP通过将关注点分离,使得业务逻辑和系统服务(如日志、事务管理等)可以独立发展,从而降低...

    spring切面小例子

    在Spring框架中,AOP(面向切面编程)是一种强大的设计模式,它允许开发者将关注点从核心业务逻辑中分离出来,例如日志记录、事务管理、性能监控等。本示例将深入探讨如何在Spring中实现AOP,特别是通过注解的方式。...

    面向切面 aop

    面向切面编程(AOP,Aspect Oriented Programming)是一种编程范式,旨在将系统中的关注点分离,使得代码更加模块化,易于维护和扩展。在传统的面向对象编程(OOP)中,业务逻辑往往与日志、事务管理、权限控制等横...

    SpringAOP切面编程依赖jar包.rar

    学习Spring开发的AOP面向切面编程时所需要的jar包,包括com.springsource.net.sf.cglib-2.2.0.jar com.springsource.org.aopalliance-1.0.0.jar com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

    spring-aop面向切面系统日志案例

    在IT行业中,Spring AOP(Aspect Oriented Programming,面向切面编程)是Spring框架的核心特性之一,它使得我们能够以一种声明式的方式处理系统中的横切关注点,如日志记录、事务管理、性能监控等。这个“spring-...

    编程语言+JAVAspring+AOP编程+面向切面

    编程语言+JAVAspring+AOP编程+面向切面**:这是一个关于JAVAspring编程语言的AOP编程的面向切面的资源,适合有一定JAVAspring基础的开发者。它介绍了JAVAspring的AOP编程的概念、原理和作用,以及如何使用JAVAspring...

Global site tag (gtag.js) - Google Analytics