第一、代理模式定义
代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。
举个例子来说明：假如说我现在想买一辆二手车，虽然我可以自己去找车源，做质量检测等一系列的车辆过户流程，但是这确实太浪费我得时间和精力了。我只是想买一辆车而已为什么我还要额外做这么多事呢？于是我就通过中介公司来买车，他们来给我找车源，帮我办理车辆过户流程，我只是负责选择自己喜欢的车，然后付钱就可以了。用图表示如下：
第二、使用代理模式的好处
中介隔离：在某些情况下，一个客户类不想或者不能直接引用一个委托对象，而代理类对象可以在客户类和委托对象之间起到中介的作用，其特征是代理类和委托类实现相同的接口。
开闭原则，增加功能代理类除了是客户类和委托类的中介之外，我们还可以通过给代理类增加额外的功能来扩展委托类的功能，这样做我们只需要修改代理类而不需要再修改委托类，
符合代码设计的开闭原则。代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后对返回结果的处理等。代理类本身并不真正实现服务，而是同过调用委托类的相关方法，来提供特定的服务。
真正的业务功能还是由委托类来实现，但是可以在业务功能执行的前后加入一些公共的服务。例如我们想给项目加入缓存、日志这些功能，我们就可以使用代理类来完成，而没必要打开已经封装好的委托类。
使用动态代理的有2个目的:一、是保护目标对象；二、增强目标对象
第三、代理的实现原理
代理模式主要包含三个角色，即抽象主题角色(Subject)、委托类角色(被代理角色，Proxied)以及代理类角色(Proxy)，如上图所示：
抽象主题角色:可以是接口，也可以是抽象类；
委托类角色：真实主题角色，业务逻辑的具体执行者；
代理类角色：内部含有对真实对象RealSubject的引用，负责对真实主题角色的调用，并在真实主题角色处理前后做预处理和后处理。
第三、代理模式的应用场景
SpringAop、日志收集、权限控制、过滤器、RPC远程调用
第三、代理模式创建的方式
静态代理和动态代理
3.1静态代理
静态代理是由程序员创建或工具生成代理类的源码，再编译代理类。
所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。一句话，自己手写代理类就是静态代理。
代码实现1:
/**
* 目标接口
*/
public interface OrderService {
public void service();
}
/**
* 目标实现类
*/
public class OrderServiceImpl implements OrderService {
@Override
public void service() {
System.out.println("实现类");
}
}
/**
* 静态代理类
*/
public class OrderServiceProxy implements OrderService {
private OrderService orderService;
public OrderServiceProxy(OrderService orderService) {
this.orderService = orderService;
}
public void before(){
System.out.println("方法执行之前增强");
}
public void after(){
System.out.println("方法执行之后增强");
}
@Override
public void service() {
before();
this.orderService.service();
after();
}
}
测试代码
public class Test001 {
public static void main(String[] args) {
OrderServiceProxy orderServiceProxy = new OrderServiceProxy(new OrderServiceImpl());
orderServiceProxy.service();
}
}
静态代理实现多数据源切换代码实现
/**
* 业务接口
*/
public interface IOrderService {
public int createOrder(Order order);
}
/**
* 动态数据源切换
*/
public class DynamicsDasourceEntity {
private final static String DEFAULT_SOURCE=null;
private static ThreadLocal<String> threadLocal = new ThreadLocal();
/**
* 还原当前数据源
*/
public static void setStore(){
threadLocal.set(DEFAULT_SOURCE);
}
/**
* 移除数据源
*/
public static void clear(){
threadLocal.remove();
}
/**
* 设置默认数据源
*/
public static void setDefaultSource(){
threadLocal.set(DEFAULT_SOURCE);
}
/**
* 根据已经知道数据源名称设置
*/
public static void setDB(String dataSource){
threadLocal.set(dataSource);
}
/**
* 根据年份设置数据源
* @param year
*/
public static void setDB(int year){
threadLocal.set("DB_"+year);
}
/**
* 获取数据源
* @return
*/
public static String getDB(){
return threadLocal.get();
}
}
/**
* 订单实体
*/
public class Order {
private Object orderInfo;
private Long crateTime;
private String id;
public Object getOrderInfo() {
return orderInfo;
}
public void setOrderInfo(Object orderInfo) {
this.orderInfo = orderInfo;
}
public Long getCrateTime() {
return crateTime;
}
public void setCrateTime(Long crateTime) {
this.crateTime = crateTime;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
/**
* 持久层
*/
public class OrderDao {
public int insert(Order order){
System.out.println("OrderDao创建Order成功");
return 1;
}
}
/**
* 静态代理类实现数据源切换
*/
public class OrderProxy implements IOrderService{
private SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd");
private IOrderService iOrderService;
public OrderProxy(IOrderService iOrderService){
this.iOrderService = iOrderService;
}
public void after(){
System.out.println("方法之后执行");
}
public void before(){
System.out.println("方法之前执行");
}
@Override
public int createOrder(Order order) {
before();
Long crateTime = order.getCrateTime();
String year = this.format.format(new Date(crateTime));
Integer dbRouter = Integer.valueOf(year);
System.out.println("静态代理已经将数据库切换到DB_"+dbRouter+"数据源处理数据");
DynamicsDasourceEntity.setDB(dbRouter);
iOrderService.createOrder(order);
after();
return 0;
}
}
/**
* 业务实现接类
*/
public class OrderServiceImpl implements IOrderService {
private OrderDao orderDao;
public OrderServiceImpl(){
orderDao = new OrderDao();
}
@Override
public int createOrder(Order order) {
return orderDao.insert(order);
}
}
/**
* 测试类
*/
public class Test001 {
public static void main(String[] args) {
OrderProxy orderProxy = new OrderProxy(new OrderServiceImpl());
Order order = new Order();
order.setCrateTime(System.currentTimeMillis());
orderProxy.createOrder(order);
}
}
3.2JDK动态代理
JDK动态代理实现的一般步骤:
1、创建被代理的接口和类;
2、实现InvoactionHandler接口，对目标接口中声明的方法统一进行处理;
3、调用Proxy静态方法，创建代理类并生成相应的代理对象
入门案例:
/**
* 目标接口
*/
public interface OrderService {
public void service();
}
/**
* 目标实现类
*/
public class OrderServiceImpl implements OrderService {
@Override
public void service() {
System.out.println("目标实现类，service方法");
}
}
/**
* 动态代理类
*/
public class OrderServiceProxy implements InvocationHandler {
private Object target;
public <T> T getIntance(Object obj){
this.target = obj;
Class<?> clazz = obj.getClass();
return (T) Proxy.newProxyInstance(clazz.getClassLoader(),
clazz.getInterfaces(),this);
}
@Override
public Object invoke(Object proxy, Method method,
Object[] args) throws Throwable {
before();
Object obj = method.invoke(this.target, args);
after();
return obj;
}
public void before(){
System.out.println("方法执行之前");
}
public void after(){
System.out.println("方法执行之后");
}
}
/**
* 测试类
*/
public class Test001 {
public static void main(String[] args) {
OrderService orderService = new OrderServiceProxy()
.getIntance(new OrderServiceImpl());
orderService.service();
}
}
使用动态代理模拟多数据源切换
/**
* 业务接口
*/
public interface IOrderService {
public int createOrder(Order order);
}
/**
* 动态数据源切换
*/
public class DynamicsDasourceEntity {
private final static String DEFAULT_SOURCE=null;
private static ThreadLocal<String> threadLocal = new ThreadLocal();
/**
* 还原当前数据源
*/
public static void setStore(){
threadLocal.set(DEFAULT_SOURCE);
}
/**
* 移除数据源
*/
public static void clear(){
threadLocal.remove();
}
/**
* 设置默认数据源
*/
public static void setDefaultSource(){
threadLocal.set(DEFAULT_SOURCE);
}
/**
* 根据已经知道数据源名称设置
*/
public static void setDB(String dataSource){
threadLocal.set(dataSource);
}
/**
* 根据年份设置数据源
* @param year
*/
public static void setDB(int year){
threadLocal.set("DB_"+year);
}
/**
* 获取数据源
* @return
*/
public static String getDB(){
return threadLocal.get();
}
}
/**
* 订单实体
*/
public class Order {
private Object orderInfo;
private Long crateTime;
private String id;
public Object getOrderInfo() {
return orderInfo;
}
public void setOrderInfo(Object orderInfo) {
this.orderInfo = orderInfo;
}
public Long getCrateTime() {
return crateTime;
}
public void setCrateTime(Long crateTime) {
this.crateTime = crateTime;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
/**
* 持久层
*/
public class OrderDao {
public int insert(Order order){
System.out.println("OrderDao创建Order成功");
return 1;
}
}
/**
* 静态代理类实现数据源切换
*/
public class OrderProxy implements InvocationHandler {
private SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd");
private Object target;
public <T> T getIntance(Object object){
this.target = object;
Class<?> clazz = object.getClass();
return (T) Proxy.newProxyInstance(clazz.getClassLoader(),
clazz.getInterfaces(),this);
}
public void after(){
System.out.println("方法之后执行");
DynamicsDasourceEntity.clear();
System.out.println("数据源已经被移除了");
}
public void before(Object target){
try {
System.out.println("方法之前执行");
Long time = (Long) target.getClass().getMethod("getCrateTime").invoke(target);
String format = this.format.format(new Date(time));
DynamicsDasourceEntity.setDB(Integer.parseInt(format));
System.out.println("动态数据源已经被切换了:"+format);
} catch (Exception ioe) {
ioe.printStackTrace();
} finally {
}
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
before(args[0]);
Object obj = method.invoke(target, args);
after();
return obj;
}
}
/**
* 业务实现接类
*/
public class OrderServiceImpl implements IOrderService {
private OrderDao orderDao;
public OrderServiceImpl(){
orderDao = new OrderDao();
}
@Override
public int createOrder(Order order) {
return orderDao.insert(order);
}
}
/**
* 测试类
*/
public class Test001 {
public static void main(String[] args) {
IOrderService orderService =
new OrderProxy().getIntance(new OrderServiceImpl());
Order order = new Order();
order.setCrateTime(System.currentTimeMillis());
orderService.createOrder(order);
}
}
3.3jdk动态代理原理分析
JDK Proxy 生成对象的步骤:
1、拿到被代理对象的引用，并获取他所有的接口，反射获取;
2、JDK Proxy重新生成一个新的类、同时新的类要实现代理被代理对象的所有实现的所有的接口;
3、动态生成java代码，把新增的业务逻辑的方法由一定的逻辑代码去调用;
4、编译新生成的java代码.class
5、重新加载到JVM中
public class Test001 {
public static void main(String[] args) {
try {
IOrderService orderService =
new OrderProxy().getIntance(new OrderServiceImpl());
Order order = new Order();
order.setCrateTime(System.currentTimeMillis());
orderService.createOrder(order);
//通过反编译查看源代码
byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{IOrderService.class});
FileOutputStream out = new FileOutputStream("E://$Proxy0.class");
out.write(bytes);
out.close();
} catch (Exception ioe) {
ioe.printStackTrace();
} finally {
}
}
}
运行上面的代码之后，生成一个$Proxy.class,用反编译插件打开
import com.yehui.dynamicproxy01.IOrderService;
import com.yehui.dynamicproxy01.Order;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $Proxy0
extends Proxy
implements IOrderService
{
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m0;
public $Proxy0(InvocationHandler paramInvocationHandler)
{
super(paramInvocationHandler);
}
public final boolean equals(Object paramObject)
{
try
{
return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
public final String toString()
{
try
{
return (String)this.h.invoke(this, m2, null);
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
public final int createOrder(Order paramOrder)
{
try
{
return ((Integer)this.h.invoke(this, m3, new Object[] { paramOrder })).intValue();
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
public final int hashCode()
{
try
{
return ((Integer)this.h.invoke(this, m0, null)).intValue();
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
static
{
try
{
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
m3 = Class.forName("com.yehui.dynamicproxy01.IOrderService").getMethod("createOrder", new Class[]
{ Class.forName("com.yehui.dynamicproxy01.Order") });
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
return;
}
catch (NoSuchMethodException localNoSuchMethodException)
{
throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
}
catch (ClassNotFoundException localClassNotFoundException)
{
throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
}
}
}
由上面的代码可以看出，新生成了$Proxy类，继承了Proxy类，同时还实现了IOrderService接口，而且还重写了createOrder()
等方法，而且在静态代码块用反射查找到了目标对象的所有方法，而且保存了所有方法的引用，在重写的的方法用反射调用目标对象的方法
注意：继承了Proxy类，实现了代理的接口，由于java不能多继承，这里已经继承了Proxy类了，不能再继承其他的类，所以JDK的动态代理不支持对实现类的代理，只支持接口的代理。
3.4Cglib动态代理
3.4.1定义
Cglib是一个强大的，高性能，高质量的代码生成类库。它可以在运行期扩展JAVA类与实现JAVA接口。其底层实现是通过ASM字节码处理框架来转换字节码并生成新的类。大部分功能实际上是ASM所提供的，Cglib只是封装了ASM，简化了ASM操作，实现了运行期生成新的class。
3.4.2原理
运行时动态的生成一个被代理类的子类（通过ASM字节码处理框架实现），子类重写了被代理类中所有非final的方法，在子类中采用方法拦截的技术拦截所有父类方法的调用，不需要被代理类对象实现接口，从而CGLIB动态代理效率比Jdk动态代理反射技术效率要高。
3.4.3实现步骤
实现MethodInterceptor接口的intercept方法后，所有生成的代理方法都调用这个方法。
intercept方法的具体参数有
obj 目标类的实例
1. method 目标方法实例（通过反射获取的目标方法实例）
2. args 目标方法的参数
3. proxy 代理类的实例
该方法的返回值就是目标方法的返回值。
代码实现:
/**
* 目标实现类
*/
public class Person {
public void findLove(){
System.out.println("找妹子");
}
}
/**
* cglib动态代理
*/
public class OrderService implements MethodInterceptor {
public <T> T getIntance(Object obj){
//相当于Proxy,代理工具类
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(obj.getClass());
enhancer.setCallback(this);
return (T) enhancer.create();
}
@Override
public Object intercept(Object o, Method method, Object[] objects,
MethodProxy methodProxy) throws Throwable {
before();
Object obj = methodProxy.invokeSuper(o, objects);
after();
return obj;
}
public void before(){
System.out.println("方法之前执行");
}
public void after(){
System.out.println("方法之后执行");
}
}
/**
* 测试类
*/
public class CglibTest {
public static void main(String[] args) {
try {
//打印到磁盘上
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"E://cglibproxy");
Person person = new OrderService().getIntance(new Person());
person.findLove();
} catch (Exception ioe) {
ioe.printStackTrace();
} finally {
}
}
}
maven依赖
<dependencies>
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.2.12</version>
</dependency>
</dependencies>
3.5动态代理与静态代理的区别
1、静态代理只能通过手动完成代理操作，如果被代理类新增方法，代理类需要同步新增，违背开闭原则
2、动态代理采用在运行时生成代码的方式取消了对代理类的扩展限制，遵循了开闭原则。
3、若无动态代理要对目标类的增强逻辑扩展，结合策略模式，只需要新增策略类变课完成无需修改代理类的代码
3.6JDK动态代理和Cglib代理的对比
1、JDK动态代理是实现了被代理对象的接口，CGLIb是继承了被代理对象，CGLIB覆盖父类的方法
2、JDK和CGLib都是在运行时期生成字节码，JDK是直接写Class字节码，cglib使用ASM框架写Class字节码，Cglib代理实现更复杂，生成代理类效率低
3、JDK代理调用方法，是通过反射机制调用，CGLib是通过FastClass机制直接调用方法Cglib执行效率更高
4、Cglib有个坑，CGLIb不能代理final的方法
5、都是生成一个新的类，去实现增强代码逻辑的功能