代理模式

静态代理

直接看例子

  1. package com.lyd.demo01;
  3. public class Host implements Rent{
  4.     @Override
  5.     public void rent() {
  6.         System.out.println("房东出租房子");
  7.     }
  8. }
  1. package com.lyd.demo01;
  3. public class Proxy implements Rent{
  4.     Host host;
  6.     public Proxy() {
  7.     }
  8.     public Proxy(Host host) {
  9.         this.host = host;
  10.     }
  12.     @Override
  13.     public void rent() {
  14.         //经过一些步骤才能租房
  15.         seeHouse();
  16.         hetong();
  17.         fare();
  18.         host.rent();
  19.     }
  20.     /*
  21.     中介能做房东不能做的事
  22.     * */
  23.     public void seeHouse(){
  24.         System.out.println("中介带你看房");
  25.     }
  26.     public void hetong(){
  27.         System.out.println("签租赁合同");
  28.     }
  29.     public void fare(){
  30.         System.out.println("收中介费");
  31.     }
  32. }
  1. package com.lyd.demo01;
  3. public class Client {
  4.     public static void main(String[] args) {
  5.         /*
  6.         不去直接找房东租房，而是找代理代理租房，代理去找房东租房
  7.         至于代理怎么租的房，我们不用管，只要找代理就行了，不用直接接触房东。
  8.         为什么不直接找房东而要找中介呢。因为中介在租房时要做一些格外的事，是房东做不了的。
  9.         别看中介租房和房东租房都是租房，中介租房多做了一些事。
  11.         在中介这里可以横向的拓展更多的事，收中介费啊，看房啊，为什么这些事不在房东这里拓展非要去中介这里拓展呢
  12.         抽象的看，房东相当于源码，你去房东这里拓展，不就是相当于改源码吗，中介相当于加一层，调用房东的同时，做格外的事，如果出错了也方便排错
  13.         这不就像是三层架构吗，dao层处理数据，要拓展一些新功能，在到service层代理dao层，横向发展
  14.         * */
  15.         Host host =new Host();
  16.         Proxy proxy =new Proxy(host);
  17.         proxy.rent();
  18.     }
  19. }

动态代理

接上面租房的例子。
主要使用InvocationHandler接口和Proxy类。
动态代理就是靠反射自动生成一个代理，不用在一个一个写代理了。

  1. package com.lyd.demo01;
  3. import com.sun.org.apache.xml.internal.security.keys.storage.implementations.CertsInFilesystemDirectoryResolver;
  5. import java.lang.reflect.InvocationHandler;
  6. import java.lang.reflect.Method;
  7. import java.lang.reflect.Proxy;
  10. public class ProxyInvocationHandler implements InvocationHandler {
  11.     private Object target;//被代理的东西
  12.     public void setTarget(Object target){
  13.         this.target=target;
  14.     }
  16.     //生成代理类
  17.     public Object getProxy(){
  18.         return Proxy.newProxyInstance(this.getClass().getClassLoader(),
  19.                 target.getClass().getInterfaces(),
  20.                 this);
  21.     }
  22.     //处理代理实例，并返回结果
  23.     @Override
  24.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  25.         //需要拓展什么业务时就可以在直接加
  26.         A();
  27.         return method.invoke(target,args);
  28.     }
  29.     public void A(){
  30.         System.out.println("执行了A方法");
  31.     }
  34. }
  1. package com.lyd.demo01;
  4. public class Client {
  5.     public static void main(String[] args) {
  6.         Host host =new Host();
  7.         ProxyInvocationHandler pih =new ProxyInvocationHandler();
  8.         pih.setTarget(host);
  9.         //动态代理的是接口
  10.         Rent proxy =(Rent) pih.getProxy();
  11.         proxy.rent();
  12.         /*执行结果：
  13.         * 执行了A方法
  14.         * 房东出租房子
  15.         * */
  16.     }
  17. }

AOP模式图

需要拓展新功能的时候，横向拓展，代理底层的源码，附加新功能
image.png

Spring实现AOP

使用AOP需要导入一个依赖包

  1.         <dependency>
  2.             <groupId>org.aspectj</groupId>
  3.             <artifactId>aspectjweaver</artifactId>
  4.             <version>1.9.1</version>
  5.             <scope>runtime</scope>
  6.         </dependency>

使用Spring的API接口

设置一个接口和实现类

  1. public interface IUserService {
  2.     public void add();
  3.     public void delete();
  4.     public void update();
  5.     public void select();
  6. }
  8. public class UserService implements IUserService{
  9.     @Override
  10.     public void add() {
  11.         System.out.println("增加了一个用户");
  12.     }
  14.     @Override
  15.     public void delete() {
  16.         System.out.println("删除了一个用户");
  17.     }
  19.     @Override
  20.     public void update() {
  21.         System.out.println("修改了一个用户");
  22.     }
  24.     @Override
  25.     public void select() {
  26.         System.out.println("查询了一个用户");
  27.     }
  28. }

我们有一个需求，在增删改查方法前后都要加上一个日志功能。
如果在上面的add，delete，update，select方法里面都加上前置日志和后置日志，很麻烦。

  1. package com.lyd.log;
  3. import org.springframework.aop.MethodBeforeAdvice;
  5. import java.lang.reflect.Method;
  7. //前置日志，看接口名字就知道是方法执行之前执行
  8. public class Log implements MethodBeforeAdvice {
  10.     //method：要执行的目标对象方法
  11.     //args:参数
  12.     //target:目标对象
  13.     @Override
  14.     public void before(Method method, Object[] args, Object target) throws Throwable {
  15.         System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
  16.     }
  17. }
  1. package com.lyd.log;
  3. import org.springframework.aop.AfterReturningAdvice;
  5. import java.lang.reflect.Method;
  7. //后置日志，看接口名字就知道是方法执行之后执行
  8. public class AfterLog implements AfterReturningAdvice {
  9.     //returnValue:返回值
  10.     @Override
  11.     public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
  12.         System.out.println("执行了"+method.getName()+"返回结果为"+returnValue);
  13.     }
  14. }

设置配置文件，注入上面的xml名称空间

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:aop="http://www.springframework.org/schema/aop"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.         https://www.springframework.org/schema/beans/spring-beans.xsd
  7.         http://www.springframework.org/schema/aop
  8.         https://www.springframework.org/schema/aop/spring-aop.xsd">
  10.     <!--注册bean-->
  11.     <bean id="userService" class="com.lyd.service.UserService"/>
  12.     <bean id="log" class="com.lyd.log.Log"/>
  13.     <bean id="afterLog" class="com.lyd.log.AfterLog"/>
  15.     <!--使用原生的Spring接口-->
  16.     <!--配置AOP:需要导入AOP的约束-->
  17.     <aop:config>
  18.         <!--切入点:expression:表达式，execution(要执行的位置)-->
  19.         <aop:pointcut id="pointcut" expression="execution(* com.lyd.service.UserService.*(..))"/>
  20.         <!--执行环绕增加-->
  21.         <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
  22.         <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
  23.     </aop:config>
  25. </beans>

执行

  1.     public static void main(String[] args) {
  2.         ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
  3.         //动态代理的是接口
  4.         IUserService user = context.getBean("userService", IUserService.class);
  5.         user.add();
  6.     }

image.png

使用自定义类实现AOP

接上面增删改查的例子
写一个新的自定义类，两个方法一前一后的执行

  1. package com.lyd.diy;
  3. /**
  4.  * @author liyadong
  5.  * @create 2022-04-01-14:57
  6.  */
  7. public class DiyPointCut {
  8.     public void before(){
  9.         System.out.println("-------方法执行前-------");
  10.     }
  11.     public void after(){
  12.         System.out.println("=========方法执行后==========");
  13.     }
  14. }

修改配置文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:aop="http://www.springframework.org/schema/aop"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.         https://www.springframework.org/schema/beans/spring-beans.xsd
  7.         http://www.springframework.org/schema/aop
  8.         https://www.springframework.org/schema/aop/spring-aop.xsd">
  10.     <!--注册bean-->
  11.     <bean id="userService" class="com.lyd.service.UserService"/>
  12.     <bean id="diy" class="com.lyd.diy.DiyPointCut"/>
  13.     <aop:config>
  14.         <!--自定义的切面，ref要引用的类-->
  15.         <aop:aspect ref="diy">
  16.             <!--切入点，就是要代理哪个方法-->
  17.             <aop:pointcut id="point" expression="execution(* com.lyd.service.UserService.*(..))"/>
  18.             <!--
  19.             通知
  20.             在哪里执行什么方法
  21.             aop:before：在切入点之前执行
  22.             aop:after：在切入点之后执行
  23.                 method：要执行的方法，这个方法就是diy里面的
  24.                 pointcut-ref：切入点
  25.             -->
  26.             <aop:before method="before" pointcut-ref="point"/>
  27.             <aop:after method="after" pointcut-ref="point"/>
  28.         </aop:aspect>
  29.     </aop:config>
  31. </beans>

执行
代码和上面的一样
image.png

注解实现AOP

设置配置文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:aop="http://www.springframework.org/schema/aop"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.         https://www.springframework.org/schema/beans/spring-beans.xsd
  7.         http://www.springframework.org/schema/aop
  8.         https://www.springframework.org/schema/aop/spring-aop.xsd">
  10.     <!--注册bean-->
  11.     <bean id="userService" class="com.lyd.service.UserService"/>
  12.     <bean id="annotationPointCut" class="com.lyd.diy.AnnotationPointCut"/>
  13.     <!--开启注解支持-->
  14.     <aop:aspectj-autoproxy/>
  16. </beans>

添加一个自定义注解实现类

  1. package com.lyd.diy;
  3. import org.aspectj.lang.ProceedingJoinPoint;
  4. import org.aspectj.lang.annotation.After;
  5. import org.aspectj.lang.annotation.Around;
  6. import org.aspectj.lang.annotation.Aspect;
  7. import org.aspectj.lang.annotation.Before;
  9. //使用注解的方式实现AOP
  10. @Aspect //标记这个类是一个切面
  11. public class AnnotationPointCut {
  13.     @Before("execution(* com.lyd.service.UserService.*(..))")
  14.     public void before(){
  15.         System.out.println("-------Ann方法执行前-------");
  16.     }
  17.     @After("execution(* com.lyd.service.UserService.*(..))")
  18.     public void after(){
  19.         System.out.println("=========Ann方法执行后==========");
  20.     }
  21.     //在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点
  22.     @Around("execution(* com.lyd.service.UserService.*(..))")
  23.     public void around(ProceedingJoinPoint jp) throws Throwable {
  24.         System.out.println("++++++++++++Ann环绕前++++++++");
  25.         //执行方法
  26.         Object object = jp.proceed();
  27.         System.out.println("++++++++++++Ann环绕后++++++++");
  28.     }
  29. }

运行代码和上面一样的
image.png