AOP
AOP:Aspect Oriented Programming (面向切面编程)通过预编译方式和运行期动态代理实现程序功能的统一
维护的一种技术。AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编
程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,
提高程序的可重用性,同时提高了开发的效率。
- AOP 的主要功能: 日志记录,性能统计,安全控制,事务处理,异常处理等等。
利用代理模式动态的实现AOP
- 首先定义一个接口
public interface UserService {
void add();
void delete();
void modify();
}
- 定义接口的实现类
public class UserServiceImpl implements UserService {
public void add() {
System.out.println("添加");
}
public void delete() {
System.out.println("删除");
}
public void modify() {
System.out.println("修改");
}
}
- 配置日志文件,在方法执行之前,执行日志
import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;
public class Log implements MethodBeforeAdvice {
//method:要执行的目标对象的方法
//objects:要被调用的方法的参数
//o:目标对象
public void before(Method method, Object[] objects, Object o) throws Throwable {
System.out.println(o.getClass().getName() +"的" +method.getName()+"方法被执行了");
}
}
- 配置日志文件,在方法执行之后执行日志
import org.springframework.aop.AfterReturningAdvice;
import java.lang.reflect.Method;
public class AfterLog implements AfterReturningAdvice {
public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
//o:返回值
//method:被调用的方法
//objects:被调用的方法对象的参数
//o1:被调用的目标对象
System.out.println("执行了"+o1.getClass().getName()+
"的"+method.getName()+"的方法"+
"返回值" + o);
}
}
- 配置 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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--注册bean-->
<bean id="userService" class="com.baidu.service.UserServiceImpl"/>
<!--注册日志类的bean-->
<bean id="log" class="com.baidu.log.Log"/>
<bean id="afterLog" class="com.baidu.log.AfterLog"/>
<aop:config>
<!--切入点
expression:表示要切入的位置
execution([*类的修饰符 类的全路径 方法 方法参数]):语法
-->
<aop:pointcut id="pointcut"
expression="execution(* com.baidu.service.UserServiceImpl.* (..))"/>
<!--执行通知,增强-->
<aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
<aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
</aop:config>
</beans>
- 导入 aspectj 织入包
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.2</version>
</dependency>
- 测试类
import com.baidu.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringAopTest {
/*
需要加入织入包依赖
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.2</version>
</dependency>
*/
@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = (UserService) context.getBean("userService");
userService.add();
userService.delete();
userService.modify();
}
}
下面看一下效果
自定义类实现AOP
- 首先创建一个实体类
public class User {
public void add(){
System.out.println("添加");
}
}
- 创建自定义类
public class util {
public void before(){
System.out.println("方法执行之前");
}
public void after(){
System.out.println("方法执行之后");
}
}
- 配置bean.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.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--创建user对象-->
<bean id="user" class="com.baidu.aop2.User"/>
<!--加载日志-->
<bean id="util" class="com.baidu.aop2.util"/>
<!--编写aop配置文件-->
<aop:config>
<aop:aspect ref="util">
<aop:pointcut id="pointcut" expression="execution(* com.baidu.aop2.User.*(..))"/>
<aop:before method="before" pointcut-ref="pointcut"/>
<aop:after method="after" pointcut-ref="pointcut"/>
</aop:aspect>
</aop:config>
</beans>
- 测试
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
User user = (User) context.getBean("user");
user.add();
}
}
- 运行结果
利用注解实现AOP
- 首先创建实体类
public class User {
public void add(){
System.out.println("添加一个用户");
}
}
- 创建日志类
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
@Aspect
public class Anno {
@Before("execution(* com.baidu.aop3.User.*(..))")
public void before(){
System.out.println("方法执行之前");
}
@After("execution(* com.baidu.aop3.User.*(..))")
public void after(){
System.out.println("方法执行之后");
}
}
- 编写配置文件beans.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.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--注册bean对象-->
<bean id="user" class="com.baidu.aop3.User"/>
<bean id="anno" class="com.baidu.aop3.Anno"/>
<!--自动装配-->
<aop:aspectj-autoproxy/>
</beans>
- 测试类
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
User user = (User) context.getBean("user");
user.add();
}
}
- 查看结果
简单介绍一下Aspectj
-
Aspect: Aspect 声明类似于 Java 中的类声明,在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。
-
Joint point:表示在程序中明确定义的点,典型的包括方法调用,对类成员的访问以及异常处理程序块的执行等等,它自身还可以嵌套其它 joint point。
-
Pointcut:表示一组 joint point,这些 joint point 或是通过逻辑关系组合起来,或是通过通配、正则表达式等方式集中起来,它定义了相应的 Advice 将要发生的地方。
-
Advice:Advice 定义了在 pointcut 里面定义的程序点具体要做的操作,它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。