代理模式是主要对我们方法执行之前与之后实现增强。
代理模式应用场景
1，日志采集
2，权限控制
3，实现aop
4,mybatis mapper
5,Spring的事务
6，全局捕获异常
7，rpc远程调用接口（传递就是接口）
8，代理数据源
9，自定义注解
aop---基于代理实现
代理模式实现的原理
代理模式主要包含三个角色，即抽象主题角色（Subject）,委托类角色（被代理角色，Proxied)以及代理类角色(Proxy)
抽象主题角色：可以是接口，也可以是抽象类；
委托类角色： 真实主题角色，业务逻辑的具体执行者；
代理类角色： 内部含有对真实对象RealSubject的引用，负责对真实主题角色的调用，并在真实主题角色处理前后做预处理和后处理。
代理模式创建方式：
相关测试代码：
package com.taotao.proxy.service;
/**
* @Author: wangjin
* @CreateTime: 2022-07-03 21:23
*/
public interface OrderService {
/**
* 追加订单数据
*/
String addOrder(String orderName);
}
package com.taotao.proxy.service.impl;
import com.taotao.proxy.service.OrderService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
/**
* @Author: wangjin
* @CreateTime: 2022-07-03 21:24
*/
@Service("OrderService")
@Slf4j
public class OrderServiceImpl implements OrderService {
@Override
public String addOrder(String orderName) {
log.info("<orderName:{}>", orderName);
log.info("addOrder方法之后处理");
return "OK";
}
}
package com.taotao.proxy.service.proxy;
import com.taotao.proxy.service.OrderService;
import lombok.extern.slf4j.Slf4j;
/**
* @Author: wangjin
* @CreateTime: 2022-07-03 21:37
*/
@Slf4j
public class OrderServiceProxy implements OrderService {
//代理类 到底是需要调用哪一个 被代理类
private OrderService orderService;
public OrderServiceProxy(OrderService orderService) {
this.orderService = orderService;
}
@Override
public String addOrder(String orderName) {
log.info("<在adder方法之前处理 orderName:{}>", orderName);
String resultString = orderService.addOrder(orderName);//调用被代理类
return resultString;
}
}
package com.taotao.proxy.service;
import com.taotao.proxy.service.impl.OrderServiceImpl;
import com.taotao.proxy.service.proxy.OrderServiceProxy;
/**
* @Author: wangjin
* @CreateTime: 2022-07-03 21:44
*/
public class Test01 {
public static void main(String[] args) {
//被代理类
OrderServiceProxy orderServiceProxy=new OrderServiceProxy(new OrderServiceImpl());
String result= orderServiceProxy.addOrder("hello");
System.out.println(result);
}
}
package com.taotao.proxy.service;
import com.taotao.proxy.service.proxy1.OrderServiceProxy;
/**
* @Author: wangjin
* @CreateTime: 2022-07-03 21:56
*/
public class Test02 {
public static void main(String[] args) {
OrderServiceProxy orderServiceProxy=new OrderServiceProxy();
String result= orderServiceProxy.addOrder("oooo");
System.out.println(result);
}
}
package com.taotao.proxy.service.proxy1;
import com.taotao.proxy.service.impl.OrderServiceImpl;
import lombok.extern.slf4j.Slf4j;
/**
* @Author: wangjin
* @CreateTime: 2022-07-03 21:51
*/
@Slf4j
public class OrderServiceProxy extends OrderServiceImpl {
//让我们代理类 继承 代理类
@Override
public String addOrder(String orderName) {
log.info("<在addOrder方法之前处理 orderName：{}>",orderName);
String result=super.addOrder(orderName);
//目标方法 执行 被代理类
log.info("<在addOrder方法之后处理 orderName：{}>",orderName);
return result;
}
}
动态代理是在实现阶段不用关心代理类，而是在运行阶段才指定哪一个对象。
动态代理类的源码是在程序运行期间由JVM根据反射等机制动态生成。
jdk动态代理的一般步骤如下：
1，创建被代理的接口和类
2，实现InvocationHandler接口，对目标接口中声明的所有方法进行统一处理；
3，调用Proxy的静态方法，创建代理类并生成相应的代理对象；
实现原理： 利用拦截器机制必须实现InvocationHandler 接口中的invoke方法实现对我们的目标方法增强
JDK API 动态代理方法：
package com.taotao.proxy.service;
import lombok.extern.slf4j.Slf4j;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* @Author: wangjin
* @CreateTime: 2022-07-03 22:36
*/
@Slf4j
public class JdkInvocationHandler implements InvocationHandler {
/**
* 目标对象
*/
private Object target;
public JdkInvocationHandler(Object target){
this.target=target;
}
/**
*
* @param proxy jdk自动生成好的代理类
* @param method 木目标对象的接口
* @param args 参数类
* @return
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
log.info("<jdk动态代理目标方法之前>,args:{}",args);
Object result=method.invoke(target,args);
log.info("<jdk动态代理目标方法之后,args:{}", args);
return result;
}
public <T> T getProxy() {
return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
}
package com.taotao;
import com.taotao.proxy.service.JdkInvocationHandler;
import com.taotao.proxy.service.OrderService;
import com.taotao.proxy.service.impl.OrderServiceImpl;
/**
* @Author: wangjin
* @CreateTime: 2022-07-05 22:25
*/
public class Test03 {
public static void main(String[] args) {
OrderService orderService=new JdkInvocationHandler(new OrderServiceImpl()).getProxy();
orderService.addOrder("taotao");
}
}
动态代理与静态代理的区别
动态代理不需要写代理类对象，通过程序自动生成，而静态代理需要我们自己写代理类对象。
