spring aop 小结

最新推荐文章于 2024-07-24 14:18:45 发布

阿尼亚学算法

最新推荐文章于 2024-07-24 14:18:45 发布

阅读量258

点赞数

文章标签： spring

本文链接：https://blog.csdn.net/qq_36498236/article/details/88994905

版权

说到spring框架，大家都不会陌生，但是说到aop，可能有很多人只是听说过这个名词，但是对什么是aop以及怎么使用aop存在很多疑惑，正好最近在学spring的aop思想，现做如下总结：

##一、什么是aop
大家可能都听说过oop，即面向对象的编程事项，与传统的面向过程的编程方法不同的是，oop思想讲究将服务（也就是函数方法）和数据（成员变量）封装成对象，由对象来调用方法，从而实现功能。因此，我们需要编写很多的类来实现我们需要的功能。但是，这种方式会导致类过多，而一些通用的方法虽然可以通过重构手法可以提取出来，但是还是有一些不足，那就是不能够自动化。我们希望能够在自动的增强某个函数的功能，不需要在每次调用的地方写任何代码，只需要写一次就OK。在这样的需求下，aop思想诞生了。aop—自动增强函数方法的思想，面向切面的编程方法。

下面一张图可以让你更加了解什么是aop思想：

也就是说如果有多个Service，aop就是研究怎么将安全，事务，其他这几个模块加入到service中去。下面我就用在java和spring环境下做实验。

##二、java、spring环境下的aop
spring中自己对aop有一套实现，底层用的是jdk的动态代理和cglib代理，但是spring发现Aspectj对aop思想的实现更加方便我们开发，所以，spring运用拿来主义，将Aspectj中的aop实现整合到spring框架中了，所以本篇只讨论Aspectj中的aop实现，工作中一般也只用到Aspectj的aop实现。

首先我们搭建一下spring的环境：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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>AspectjDemo</groupId>
  <artifactId>cn.ljtnono</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>AspectDemo</name>
  
    <dependencies>
  	<dependency>
  		<groupId>org.springframework</groupId>
  		<artifactId>spring-aop</artifactId>
  		<version>4.2.4.RELEASE</version>
  	</dependency>
  	<dependency>
  		<groupId>org.springframework</groupId>
  		<artifactId>spring-aspects</artifactId>
  		<version>4.2.4.RELEASE</version>
  	</dependency>
  	<dependency>
  		<groupId>org.springframework</groupId>
  		<artifactId>spring-beans</artifactId>
  		<version>4.2.4.RELEASE</version>
  	</dependency>
  	<dependency>
  		<groupId>org.springframework</groupId>
  		<artifactId>spring-context</artifactId>
  		<version>4.2.4.RELEASE</version>
  	</dependency>
  	<dependency>
  		<groupId>org.springframework</groupId>
  		<artifactId>spring-context-support</artifactId>
  		<version>5.0.8.RELEASE</version>
  	</dependency>
  	<dependency>
  		<groupId>org.springframework</groupId>
  		<artifactId>spring-core</artifactId>
  		<version>4.2.4.RELEASE</version>
  	</dependency>
  	<dependency>
  		<groupId>org.springframework</groupId>
  		<artifactId>spring-expression</artifactId>
  		<version>4.2.4.RELEASE</version>
  	</dependency>
  	<dependency>
  		<groupId>org.slf4j</groupId>
  		<artifactId>slf4j-log4j12</artifactId>
  		<version>1.7.2</version>
  	</dependency>
  	<dependency>
  		<groupId>log4j</groupId>
  		<artifactId>log4j</artifactId>
  		<version>1.2.12</version>
  	</dependency>
  	<dependency>
  		<groupId>junit</groupId>
  		<artifactId>junit</artifactId>
  		<version>4.12</version>
  	</dependency>
  	<dependency>
  		<groupId>org.springframework</groupId>
  		<artifactId>spring-test</artifactId>
  		<version>4.2.4.RELEASE</version>
  	</dependency>
  	
  	<!-- cglib代理模式  类模式代理 -->
  	<dependency>
	    <groupId>cglib</groupId>
	    <artifactId>cglib</artifactId>
	    <version>3.2.8</version>
	</dependency>
    </dependencies>
  
  <build>
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
    </plugins>
  </build>

</project>

项目结构图如下：

这里先创建一个切面t类，这是一个普通的pojo类。（不知道什么是切面？点击这里）

package cn.ljtnono.aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

//@Aspect
@Component("Aspect1")
public class Aspect1 {
	
	//@Before("execution( * *..SomeService*.firstService(..))")
	public void myBefore() {
		System.out.println("这是一个前置通知");
	}
}

创建一个方法，一个前置通知。编写要增强的类的接口以及实现类

package cn.ljtnono.service;

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

 
public interface SomeService {
	
	
	void firstService();
	
	void secondService();
	
	void thiredService();
}

package cn.ljtnono.service;

import org.springframework.stereotype.Service;

@Service(value="SomeService")
public class SomeServiceImpl  {

	
	public void firstService() {
		// TODO Auto-generated method stub
		System.out.println("======执行了firstService方法");
	}

	
	public void secondService() {
		// TODO Auto-generated method stub
		System.out.println("======执行了secondService方法");

	}

	
	public void thiredService() {
		// TODO Auto-generated method stub

		System.out.println("======执行了thiredService方法");
	}
	
	

}

在spring配置文件中配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:mybatis="http://mybatis.org/schema/mybatis-spring"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xmlns:p="http://www.springframework.org/schema/p"
	   xmlns:context="http://www.springframework.org/schema/context"
	   xmlns:mvc="http://www.springframework.org/schema/mvc"
	   xmlns:aop="http://www.springframework.org/schema/aop"
	   xmlns:tx="http://www.springframework.org/schema/tx"
	   xmlns:cache="http://www.springframework.org/schema/cache"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans
			            http://www.springframework.org/schema/beans/spring-beans.xsd
			            http://www.springframework.org/schema/context
			            http://www.springframework.org/schema/context/spring-context.xsd
			            http://www.springframework.org/schema/mvc
			            http://www.springframework.org/schema/mvc/spring-mvc.xsd
			            http://www.springframework.org/schema/tx
			            http://www.springframework.org/schema/tx/spring-tx.xsd
			            http://mybatis.org/schema/mybatis-spring
			            http://mybatis.org/schema/mybatis-spring.xsd
						http://www.springframework.org/schema/cache
						http://www.springframework.org/schema/cache/spring-cache-3.1.xsd
						http://www.springframework.org/schema/aop
        				http://www.springframework.org/schema/aop/spring-aop-3.1.xsd">
	
	<!-- 开启注解配置 -->
	<context:component-scan base-package="cn.ljtnono" />
	
	<aop:config>
		<aop:pointcut expression="execution( * *..SomeService*.firstService(..))" id="myPointCut"/>
		<aop:aspect ref="Aspect1">
			<aop:before method="myBefore" pointcut-ref="myPointCut"/>
		</aop:aspect>
	</aop:config>
	
</beans>

aop:config中的配置：首先要配置一个切入点，然后配置切面的实现。这里应该容易理解。这其中需要aspect类和目标对象被容器识别，也就是必须交给spring管理这两个对象。其中execution表达式详解见我的另一篇博文。

现在测试：

package cn.ljtnono.test;

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

import cn.ljtnono.service.SomeService;
import cn.ljtnono.service.SomeServiceImpl;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:applicationContext.xml"})
public class Aspect1Test {
	
	
	
	
	@Test
	public void testBefore() {
		
		ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
		SomeServiceImpl service = (SomeServiceImpl) ac.getBean("SomeService");
		service.firstService();
	}
}

至此，一个简单的aop demo完成了，有不懂的可以查看以下资料：

AOP execution表达式详解：https://www.jianshu.com/u/0eac251981be

阿尼亚学算法

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
spring aop 小结

说到spring框架，大家都不会陌生，但是说到aop，可能有很多人只是听说过这个名词，但是对什么是aop以及怎么使用aop存在很多疑惑，正好最近在学spring的aop思想，现做如下总结：##一、什么是aop大家可能都听说过oop，即面向对象的编程事项，与传统的面向过程的编程方法不同的是，oop思想讲究将服务（也就是函数方法）和数据（成员变量）封装成对象，由对象来调用方法，从而实现功能。因此，...
复制链接

扫一扫