代理模式
- 为什么要学习代理模式，aop的底层机制就是动态代理。
代理模式
创建一个抽象角色，例如用户业务，crud
//抽象角色：增删改查业务public interface UserService {void add();void delete();void update();void query();}
需要一个真实对象来完成这些增删改查操作
//真实对象，完成增删改查操作的人 public class UserServiceImpl implements UserService { public void add() { System.out.println("增加了一个用户"); } public void delete() { System.out.println("删除了一个用户"); } public void update() { System.out.println("更新了一个用户"); } public void query() { System.out.println("查询了一个用户"); } }需求来了，需要增加一个日志功能，
- 思路1 实现类中添加代码，
- 思路2 使用代理来做，不改变原代码的情况下实现
设置一个代理类来处理日志，代理角色 ```java //代理角色，在这里面增加日志的实现 // userServiceProxy 为 userService 接口的一个实现 public class UserServiceProxy implements UserService { // 将 原实现类作为属性引入进当前实现类 private UserServiceImpl userService; // set方法，提供一个对其进行动态赋值的入口 public void setUserService(UserServiceImpl userService) {
this.userService = userService;}
public void add() {
log("add"); // 代理的新增方法 userService.add(); // 原实现类方法}
public void delete() {
log("delete"); userService.delete();}
public void update() {
log("update"); userService.update();}
public void query() {
log("query"); userService.query();}
public void log(String msg){
System.out.println("执行了"+msg+"方法");}
}
如上，在不改变原生代码的情况下对其进行了拓展<br />
<a name="3YdX6"></a>
# 动态代理
- 动态代理的角色和静态代理一样
- 动态代理的代理类是动态生成的，静态代理的代理类是提前写好的
- 动态代理分为两类，一类基于接口的动态代理，以类是基于类的动态代理
- 基于接口的动态代理 == jdk动态代理
- 基于类的动态代理 ==cglib
- 现在常见的是javasist 来生成动态代理，
- 下面使用JDK的原生代码来实现，其余道理一样。
<a name="AInjK"></a>
# 动态代理的好处
- 可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .<br />
- 公共的业务由代理来完成 . 实现了业务的分工 ,<br />
- 公共业务发生扩展时变得更加集中和方便 .<br />
- 一个动态代理 , 一般代理某一类业务<br />
- 一个动态代理可以代理多个类，代理的是接口！
<a name="mr1Ub"></a>
# 什么是AOP
- AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
<a name="iHVLg"></a>
# AOP在Spring中的作用
- 提供声明式事务：允许用户自定义切面
以下名次需要了解：
- 横切关注点：跨越应用程序多个模块的方法或者功能，即是，与我们业务逻辑无关，但是需要关注的部分，就是横切关注点，如，日志，安全，缓存，事务等等。
- 切面 ASPECT 横切关注点，被模块化的特殊对象，即，它是一个类
- 通知 Adivice 切面必须完成的工作，即，它是类中一个方法
- 目标 Target 被通知对象
- 代理 Proxy 想目标对象应用通知之后创建的对象。
- 切入点 PointCut 切面通知 执行的 ‘地点’ 定义
- 链接点 JoinPoint 与切入点匹配的执行点
- 
- SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice:
- 即是，AOP在不改变原有代码的情况下，去增加新的功能。
<a name="mxgB7"></a>
# Spring 实现aop
- 导入依赖
```java
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
</dependency>
通过Spring API实现
首先，业务接口，实现类 ```java public interface UserService {
public void add();
public void delete();
public void update();
public void search();
}
```java
public class UserServiceImpl implements UserService{
@Override
public void add() {
System.out.println("增加用户");
}
@Override
public void delete() {
System.out.println("删除用户");
}
@Override
public void update() {
System.out.println("更新用户");
}
@Override
public void search() {
System.out.println("查询用户");
}
}
之后是增强类，一个是前置增强，一个后置增强。
public class Log implements MethodBeforeAdvice { //method : 要执行的目标对象的方法 //objects : 被调用的方法的参数 //Object : 目标对象 @Override public void before(Method method, Object[] objects, Object o) throws Throwable { System.out.println( o.getClass().getName() + "的" + method.getName() + "方法被执行了"); } }public class AfterLog implements AfterReturningAdvice { //returnValue 返回值 //method被调用的方法 //args 被调用的方法的对象的参数 //target 被调用的目标对象 @Override public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable { System.out.println("执行了" + target.getClass().getName() +"的"+method.getName()+"方法," +"返回值："+returnValue); } }最后去spring的文件中注册 , 并实现aop切入实现 , 注意导入约束
<?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.kuang.service.UserServiceImpl"/> <bean id="log" class="com.kuang.log.Log"/> //前置方法所在类的bean <bean id="afterLog" class="com.kuang.log.AfterLog"/> // 后置方法所在类的bean <!--aop的配置--> <aop:config> <!--切入点 expression:表达式匹配要执行的方法--> <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/> <!--执行环绕; advice-ref执行方法 . pointcut-ref切入点--> <aop:advisor advice-ref="log" pointcut-ref="pointcut"/> <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/> </aop:config> </beans>测试
public class MyTest { @Test public void test(){ ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); UserService userService = (UserService) context.getBean("userService"); userService.search(); } }AOP重要性： 非常重要，要理解思想。
目标待增强业务类依然是 userServiceImpl
写一个自定义切入类 ```java public class DiyPointcut {
public void before(){
System.out.println("---------方法执行前---------");} public void after(){
System.out.println("---------方法执行后---------");}
}
- xml文件中进行配置
```java
<!--第二种方式自定义实现-->
<!--注册bean-->
<bean id="diy" class="com.kuang.config.DiyPointcut"/>
<!--aop的配置-->
<aop:config>
<!--第二种方式：使用AOP的标签实现-->
<aop:aspect ref="diy">
<aop:pointcut id="diyPonitcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
<aop:before pointcut-ref="diyPonitcut" method="before"/>
<aop:after pointcut-ref="diyPonitcut" method="after"/>
</aop:aspect>
</aop:config>
测试
public class MyTest { @Test public void test(){ ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); UserService userService = (UserService) context.getBean("userService"); userService.add(); } }注解实现AOP
编写一个注解实现的增强类 ```java package com.kuang.config;
import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.After; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before;
@Aspect public class AnnotationPointcut { @Before(“execution( com.kuang.service.UserServiceImpl.(..))”) public void before(){ System.out.println(“————-方法执行前————-“); }
@After("execution(* com.kuang.service.UserServiceImpl.*(..))")
public void after(){
System.out.println("---------方法执行后---------");
}
@Around("execution(* com.kuang.service.UserServiceImpl.*(..))")
public void around(ProceedingJoinPoint jp) throws Throwable {
System.out.println("环绕前");
System.out.println("签名:"+jp.getSignature());
//执行目标方法proceed
Object proceed = jp.proceed();
System.out.println("环绕后");
System.out.println(proceed);
}
}
- spring配置文件中，注册bean，并增加支持注解的配置。
```java
<!--第三种方式:注解实现-->
<bean id="annotationPointcut" class="com.kuang.config.AnnotationPointcut"/>
<aop:aspectj-autoproxy/>
- aop：aspectj-autoproxy 说明
```java
通过aop命名空间的
若有收获，就点个赞吧
0 人点赞
