静态代理设计模式
- 1.为什么需要代理设计模式
- 2.代理设计模式
  - 代理开发的核心要素
Spring动态代理开发
动态代理开发详解
- 额外功能的详解
  - MethodBeforeAdvice 分析
AOP的底层实现原理
- 动态代理类的创建
  - JDK的动态原理（原理＋编码）
  - CGlib 的动态代理

静态代理设计模式

1.为什么需要代理设计模式

在JAVAEE分层开发中Service层对我们最重要.Servlce包含了哪些业务代码呢？

核心功能，代码量比较多：业务运算，DAO调用
额外功能，（附加代码，不属于业务，可有可无，代码量小）：事务、日志、性能…

问题：额外功能书写在Service层好不好？

Service层的调用角度来说（Controller）:需要在Servce层书写额外功能。
从软件设计者来说，Service不需要写额外功能。

具体例子房屋中介：
引入一个房屋中介代理类，它的作用就是提供额外功能，调用目标类（原始类）核心功能

2.代理设计模式

概念：通过代理类，为原始类（目标类）增加额外功能
好处：利于原始类(目标类)的维护
名词解释
目标类/原始类：指的是业务类（核心功能—>业务运算、DA0调用）
目标方法/原始方法：目标类中的方法就是原始方法
额外功能/附加功能：日志、事务、性能……

代理开发的核心要素

代理类=目标类+额外功能+原始类实现相同的接口

房东 --- 目标类
public interface UserService {
m1
m2
}
public UserServiceImpl implements UserServiceImpl {
m1 ---> 业务运算、调用DAO
m2 
}
----------------------------------------------------
中介 --- 代理类：要实现目标类相同的接口
public UserServiceProxy implements UserService {
m1
m2
}

静态代理的编码

静态代理：为每一个原始类，手工编写一个代理类（.java.class）

public class User {}
public interface UserService {
    void register(User user);
    boolean login(String name, String password);
}
public class UserServiceImpl implements UserService {
    @Override
    public void register(User user) {
        System.out.println("UserServiceImpl.register 业务运算 + DAO");
    }
    @Override
    public boolean login(String name, String password) {
        System.out.println("UserServiceImpl.login 业务运算 + DAO");
        return true;
    }
}
/**
 * 静态代理类编码实现
 */
public class UserServiceProxy implements UserService { // 实现原始类相同的接口
    private UserService userService = new UserServiceImpl(); // 代理类中必须有原始类
    @Override
    public void register(User user) {
        System.out.println("---log---"); // 额外功能
        userService.register(user);
    }
    @Override
    public boolean login(String name, String password) {
        System.out.println("---log---"); // 额外功能
        return userService.login(name, password);
    }
}

静态代理存在的问题
1.静态类文件数量过多，不利于项目管理
UserServiceImpl、UserServiceProxy
OrderServiceImpl、OrderServiceProxy
…
2.额外功能维护性差，在代理类中修改额外功能比较麻烦

Spring动态代理开发

概念：通过代理类为原始类（目标类）增加额外功能
好处：利于原始类（目标类）的维护

搭建环境开发（引入依赖）

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>5.1.14.RELEASE</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.8.9</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.13</version>
</dependency>

Spring动态代理的开发步骤（5步）

1.创建原始对象（目标对象）

public interface UserService {
    void register(User user);
    boolean login(String name, String password);
}
public class UserServiceImpl implements UserService {
    @Override
    public void register(User user) {
        System.out.println("UserServiceImpl.register 业务运算 + DAO");
    }
    @Override
    public boolean login(String name, String password) {
        System.out.println("UserServiceImpl.login 业务运算 + DAO");
        return true;
    }
}

2.额外功能MethodBeforeAdvice接口

public class Before implements MethodBeforeAdvice {
    /**
     * 作用: 把需要运行在原始方法执行之前运行的额外功能, 书写在 before 方法中
     */
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println("---method before advice log---");
    }
}

3.定义切入点：额外功能的加入
目的：由程序员根据自己的需要，决定额外功能加入给哪个原始方法（register,login）

 <!--切入点:额外功能的加入-->
    <!--目的: 由程序员根据自己的需要，决定额外功能加入给哪个原始方法(register、login)-->
   <!-- 简单的测试：所有方法都做为切入点，都加入额外的功能-->
    <aop:config>
        <aop:pointcut id="pc" expression="execution(* * (..))"/>
    </aop:config>

4.组装（2，3整合）

<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
                           https://www.springframework.org/schema/aop/spring-aop.xsd">
    <bean id="userService" class="com.yusael.aop.UserServiceImpl"/>
    <!-- 额外功能 -->
    <bean id="before" class="com.yusael.aop.Before"/>
    <!--切入点:额外功能的加入-->
    <!--目的：由程序员根据自己的需要，决定额外功能加入给哪个原始方法(register、login)-->
   <!-- 简单的测试：所有方法都做为切入点，都加入额外的功能-->
    <aop:config>
        <aop:pointcut id="pc" expression="execution(* * (..))"/>
        <!--表达的含义: 所有的方法 都加入before的额外功能-->
        <aop:advisor advice-ref="before" pointcut-ref="pc"/>
    </aop:config>
</beans>

5.调用
目的：获得Spring工厂创建的动态代理对象，并进行调用
注意：
1.Spring的工厂通过原始对象的id值获取的是代理对象
2.获得代理对象后，可以通过声明接口类型，进行对象的存醋。

/**
 * 用于测试动态代理
 */
@Test
public void test1() {
    ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
    UserService userService = (UserService) ctx.getBean("userService");
    userService.login("admin", "1234");
    userService.register(new User());
}

动态代理细节分析

Spring创建的动态代理类在哪里？

Spring框架在运行时，通过动态字节码技术，在JVM创建的，运行在JVM内部，等程序结束后，会后JVM一起消失。

什么是动态字节码技术？

通过第三方动态字节码框架，在 JVM 中创建对应类的字节码，进而创建对象，当虚拟机结束，动态字节码跟着消失。

结论：

动态代理不需要定义类文件，都是 JVM 运行过程中动态创建的；所以不会造成静态代理的缺点：类⽂件数量过多，影响项目管理的问题。

动态代理编程简化代理的开发

在额外功能不改变的前提下，创建其他目标类（原始类）的代理对象时，只需要指定原始（目标）对象即可。

动态代理使得 额外功能的维护性大大增强。

动态代理开发详解

额外功能的详解

MethodBeforeAdvice 分析
1.MethodBeforeAdvice 接口作用：额外功能运行在原始方法执行之前，进行额外功能操作。
```java public class Before implements MethodBeforeAdvice { /**
- 作用: 把需要运行在原始方法执行之前运行的额外功能, 书写在 before 方法中 *
- Method: 额外功能所增加给的那个原始方法
- login
- register
- showOrder *
- Object[]: 额外功能所增加给的那个原始方法的参数
- String name,String password
- User
*
- Object: 额外功能所增加给的那个原始对象
- UserServiceImpl
- OrderServiceImpl */ @Override public void before(Method method, Object[] objects, Object o) throws Throwable { System.out.println(“—-new method before advice log—-“); }

}

<a name="MZ3hh"></a>
### MethodInterceptor（方法拦截器）
methodinterceptor 接口：额外功能可以根据需要运行在原始方法执行 **前、后、前后**。
- 参数：MethodInvocation：额外功能所增加给的那个原始方法 (login, register)
- 返回值：Object：原始方法的返回值 (没有就返回 null)
- invocation.proceed()：原始方法运行
 额外功能运行在原始方法 **之前**：  
```java
public class Around implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        System.out.println("---额外功能运行在原始方法执行之前---");
        Object ret = methodInvocation.proceed(); // 原始方法运行, 获取原始方法的返回值
        return ret;
    }
}

额外功能运行在原始方法之后：

public class Around implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        Object ret = methodInvocation.proceed(); // 原始方法运行, 获取原始方法的返回值
        System.out.println("---额外功能运行在原始方法执行之后---");
        return ret;
    }
}

额外功能运行在原始方法 之前、之后：

public class Around implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        System.out.println("---额外功能运行在原始方法执行之前---");
        Object ret = methodInvocation.proceed(); // 原始方法运行, 获取原始方法的返回值
        System.out.println("---额外功能运行在原始方法执行之后---");
        return ret;
    }
}

AOP的底层实现原理

核心问题：
1.AOP如何创建动态代理类？
动态字节码技术

2.Spring工厂如何加工创建代理对象？
通过原始对象的id值，获得的是代理对象

动态代理类的创建

JDK的动态原理（原理＋编码）

Proxy.newproxyInstance方法参数详解

public class TestJDKProxy {
    public static void main(String[] args) {
        //创建原始对象
        UserService userService= new UserServiceimpl();
        //2.JDK动态代理
        InvocationHandler handler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("---- proxy log ----");
                //原始方法运行
                Object invoke = method.invoke(userService, args);
                System.out.println("...proxy log....");
                return invoke;
            }
        };
        UserService userServiceProxy = (UserService)Proxy.newProxyInstance(userService.getClass().getClassLoader(), userService.getClass().getInterfaces(), handler);
        userServiceProxy.login("123","456");
    }
}

CGlib 的动态代理

CGlib 创建动态代理的原理：通过父子继承关系创建代理对象，原始类作为父类，代理类作为子类，这样既可以保证 2 者方法⼀致，同时在代理类中可以提供新的实现（额外功能+原始方法）。

 public static void main(String[] args) {
        //1.创建原始对象
        UserService1 userService = new UserService1();
        /**
         2. 通过 cglib 方式创建动态代理对象
         对比 jdk 动态代理 ---> Proxy.newProxyInstance(classLoader, interface, invocationHandler);
         Enhancer.setClassLoader()
         Enhancer.setSuperClass()
         Enhancer.setCallBack() ---> MethodInterceptor(cglib)
         Enhancer.createProxy() ---> 创建代理对象
         */
        Enhancer enhancer = new Enhancer();
        enhancer.setClassLoader(userService.getClass().getClassLoader());
        enhancer.setSuperclass(userService.getClass());
        MethodInterceptor methodInterceptor = new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("额外功能");
                Object invoke = method.invoke(userService, objects);
                return invoke;
            }
        };
        enhancer.setCallback(methodInterceptor);
        UserService1 userServiceProxy = (UserService1)enhancer.create();
        userServiceProxy.login("222","34243");
    }
}

总结：
1.JDK动态代理
Proxy.newProxyInstance:通过接口创建代理实现类
2.Cglib动态代理
Enhance:通过继承父类创建代理类

Java 学习笔记

SpringAOP编程