深入理解静态与动态代理设计模式：从理论到实践

静态代理设计模式

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

javaEE分层开发中，哪个层次对于我们来讲最重要

DAO---->Service---->Controller

JavaEE分层中，最为重要的是Service层

Service层包含了那些代码

Service层=核心功能(几十行上百代码) +额外功能(附加功能)

1.核心功能

业务运算

DAO调用

2.额外功能

1.不属于业务

2.可有可无

3.代码量很小

事务、日志、性能

额外功能书写在Service层中好不好？

Service层调用者角度(Controller):需要再Service层中书写额外功能

软件设计者:Service层不需要额外功能

现实生活中的解决方案

对话例子:

场景 1：直接找房东租房（无代理模式）

房客：你好，我想租你的房子，能带我看看吗？

房东：额……我只负责签合同，广告、带看这些不归我管，你自己去找吧。

房客：（无奈）这太麻烦了，我得自己找房源、安排时间，还可能被忽悠。

场景 2：通过中介租房（静态代理）

房客：你好，我想租房，你能帮我介绍吗？

中介：当然！我这有很多房源信息，还能带你去看房，满意的话就签合同。

（中介带房客去看房后……）

房客：这房子不错，我想租。

中介：好，那我帮你联系房东签合同吧。

房东：好的，我们来签合同吧。（完成租房）

场景 3：更换中介（动态代理）

房客：（租房体验不满意）这个中介效率太低了，我想换个更好的。

中介公司：没问题！我们这有多个中介，你可以换一个更专业的。

（更换代理后，房客又顺利租到了房子）

2.代理设计模式

1.1概念

通过代理类：为原始类(目标)增加额外功能

好处：利于原始类(目标的维护)

1.2名词解释

1.目标类原始类
指的是业务类(核心功能--->业务运算 DAO调用)

2.目标方法原始方法

目标类(原始类)中的方法就是目标方法(原始方法)

3.额外功能(附加功能)

日志、事务、性能

1.3代理开发的核心要素

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

房东---->public interface UserService{

m1方法

m2方法

}

UserServiceImpl implements UserService{

m1---->业务调用 DAO调用

m2

}

UserServiceProxy implements UserService

1.4编码

静态代理:为每一个原始类，手工编写一个代理类

java">public class UserServiceProxy implements UserService{private UserServiceImpl userService=new UserServiceImpl();@Overridepublic void register(User user) {System.out.println("---log");userService.register(user);}@Overridepublic void login(String name, String password) {System.out.println("---log");userService.login(name, password);}
}

1.5静态里存在的问题

1.静态类文件数量过多，不利于项目管理

UserServiceImpl UserServiceProxy

OrderServiceImpl OrderServiceProxy

2.额外功能维护性差

代理类中额外功能修改复杂

Spring动态代理

概念：通过代理类为原始类(目标类增加额外功能)

好处:利于原始类(目标类的维护)

搭建开发环境

java"><dependency><groupId>org.springframework</groupId><artifactId>spring-aop</artifactId><version>5.2.14.RELEASE</version></dependency><dependency><groupId>org.aspectj</groupId><artifactId>aspectjrt</artifactId><version>1.8.8</version></dependency><dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.8.3</version></dependency>

Spring动态代理开发步骤

1.创建原始对象(目标对象)

java">public class UserServiceImpl implements UserService{@Overridepublic void register(User user) {System.out.println("用户注册成功");}@Overridepublic void login(String name, String password) {System.out.println("用户登录成功");}
}

<bean id="userService" class="proxy.UserServiceImpl"></bean>

2.额外功能

MethodBeforeAdvice接口

额外功能书写在接口的视线中，运行在原始方法执行之前运行额外功能

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

3.定义切入点

切入点:额外功能加入的位置

目的:由程序员根据自己的需要，决定额外功能加入倒哪个原始方法中

rigister

login

简单测试:所有方法都作为切入点加入额外功能

java">  <aop:config>
<!--        所有的方法 都作为切入点 加入额外功能 login register--><aop:pointcut id="pc" expression="execution(* *(..))"/></aop:config>

4.组装(2.3整合)

java"><aop:config>
<!--        所有的方法 都作为切入点 加入额外功能 login register--><aop:pointcut id="pc" expression="execution(* *(..))"/><aop:advisor advice-ref="before" pointcut-ref="pc"></aop:advisor></aop:config>

5.调用

目的:获得Spring工厂创建的动态代理对象，并进行调用

ApplicationContext applicaton=new ClassPathXmlApplication("/applicationContext.xml");

注意:

1.Spring工厂通过原始对象的id值获得是代理对象

2.获得代理对象后，可以通过生命接口类型，进行对象存储

UserService userService=(UserService)application.getBean("userService");

application.getBean("userService")

动态代理细节分析

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

Spring框架在运行时，通过动态字节码奇数，在JVM创建，运行在JVM内部，等程序结束后，回合JVM一起消失

动态字节码技术

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

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

2.动态代理编程简化代理开发

在额外功能不改变的情况下，创建其它目标类(原始类)的代理对象时，只需要指定原始(目标对象)即可。

3.动态代理可维护性大大增强

(当前代理不想用直接替换即可)

java"><bean id="userService" class="proxy.UserServiceImpl"></bean><bean id="before" class="dynamic.Before"></bean><bean id="before2" class="dynamic.Before2"></bean><aop:config>
<!--        所有的方法 都作为切入点 加入额外功能 login register--><aop:pointcut id="pc" expression="execution(* *(..))"/><aop:advisor advice-ref="before2" pointcut-ref="pc"></aop:advisor></aop:config>

MethodBeforeAdvice详解

接口作用:额外功能在原始方法执行之前，进行额外功能操作
public void before(Method method, Object[] objects, Object o) throws Throwable {System.out.println("------额外功能开发--------");
}
Object O:额外对象所增加给的原始对象
Object []objects:所增加切入点方法的参数
Method method:额外功能所增加的所在的方法 切入点