代理模式

为什么要学习代理模式，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 />![image.png](https://cdn.nlark.com/yuque/0/2021/png/1608527/1616416691161-a1d3450c-0686-4247-a86e-ada26827c3c7.png#align=left&display=inline&height=191&margin=%5Bobject%20Object%5D&name=image.png&originHeight=381&originWidth=1038&size=115817&status=done&style=none&width=519)
<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可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
![image.png](https://cdn.nlark.com/yuque/0/2021/png/1608527/1616417760508-901ff4ba-d266-44fd-bef9-eec67771ce80.png#align=left&display=inline&height=276&margin=%5Bobject%20Object%5D&name=image.png&originHeight=551&originWidth=952&size=197183&status=done&style=none&width=476)
<a name="iHVLg"></a>
# AOP在Spring中的作用
- 提供声明式事务：允许用户自定义切面
以下名次需要了解：
- 横切关注点：跨越应用程序多个模块的方法或者功能，即是，与我们业务逻辑无关，但是需要关注的部分，就是横切关注点，如，日志，安全，缓存，事务等等。
- 切面 ASPECT 横切关注点，被模块化的特殊对象，即，它是一个类
- 通知 Adivice 切面必须完成的工作，即，它是类中一个方法
- 目标 Target 被通知对象
- 代理 Proxy 想目标对象应用通知之后创建的对象。
- 切入点 PointCut 切面通知 执行的 ‘地点’ 定义
- 链接点 JoinPoint 与切入点匹配的执行点
- ![image.png](https://cdn.nlark.com/yuque/0/2021/png/1608527/1616418451912-ffec2733-d6bd-4f37-80d7-4b3a6e48116d.png#align=left&display=inline&height=236&margin=%5Bobject%20Object%5D&name=image.png&originHeight=471&originWidth=744&size=209292&status=done&style=none&width=372)
- SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice:
![image.png](https://cdn.nlark.com/yuque/0/2021/png/1608527/1616418472232-76627357-672d-4304-887a-8f27977ffb84.png#align=left&display=inline&height=237&margin=%5Bobject%20Object%5D&name=image.png&originHeight=474&originWidth=762&size=154796&status=done&style=none&width=381)
- 即是，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重要性：非常重要，要理解思想。
- Spring AOp就是将公共的业务（日志，安全等）和领域业务结合起来，当执行领域业务时，将会吧公公业务加起来，实现公公业务的重复利用，领域业务更加纯粹，专注于业务代码，本质还是动态代理。
  自定义类实现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命名空间的声明自动为spring容器中那些配置@aspectJ切面的bean创建代理，织入切面。当然，spring 在内部依旧采用AnnotationAwareAspectJAutoProxyCreator进行自动代理的创建工作，但具体实现的细节已经被隐藏起来了

有一个proxy-target-class属性，默认为false，表示使用jdk动态代理织入增强，当配为时，表示使用CGLib动态代理技术织入增强。不过即使proxy-target-class设置为false，如果目标类没有声明接口，则spring将自动使用CGLib动态代理。 ```

Java 测试

Spring Review -Day03 代理模式&AOP

代理模式

静态代理举例

通过Spring API实现

自定义类实现AOP

注解实现AOP