1.代理模式简介
通过代理控制对象的访问,可以详细访问某个对象的方法，在这个方法调用处理，或调用后处理。既(AOP微实现) ,AOP核心技术面向切面编程。
2.应用场景
SpringAOP、事物原理、日志打印、权限控制、远程调用、安全代理 可以隐蔽真实角色。
3.代理的分类
1、静态代理(静态定义代理类)
2、动态代理(动态生成代理类)
3、Jdk自带动态代理
4、Cglib 、javaassist（字节码操作库）
4.静态代理
1.什么是静态代理
由程序员创建或工具生成代理类的源码，再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。
优点：可以在不修改目标对象的前提下扩展目标对象的功能。
缺点：
- 冗余。由于代理对象要实现与目标对象一致的接口，会产生过多的代理类。
- 不易维护。一旦接口增加方法，目标对象与代理对象都要进行修改。
2.代码实现
由上图的调用关系可以实现为，建立一个接口IUserDao，一个实现类UserDaoImpl，和一个代理类UserDaoProxy，实现类和代理类都实现了接口，代理类通过调用实现类从而获取实现类的功能。
简单代码如下：
package com.designpattern.proxy.staticproxy;
/**
* @description: IUserDao接口
* @author: Codegitz
* @create: 2020-05-18 12:04
**/
public interface IUserDao {
void save();
}
package com.designpattern.proxy.staticproxy;
/**
* @description: IUserDao实现类
* @author: Codegitz
* @create: 2020-05-18 12:05
**/
public class UserDaoImpl implements IUserDao {
@Override
public void save() {
System.out.println("UserDaoImpl.save execute ....");
}
}
package com.designpattern.proxy.staticproxy;
/**
* @description: 代理类
* @author: Codegitz
* @create: 2020-05-18 12:06
**/
public class UserDaoProxy implements IUserDao {
private IUserDao target;
public UserDaoProxy(IUserDao target){
this.target = target;
}
@Override
public void save() {
System.out.println("UserDaoProxy.save execute before IUserDao.save....");
//通过在调用实现类之前，代理类先执行一些处理，可以实现静态代理，此部分为写死功能，不好修改
target.save();
//同理，执行后续操作
System.out.println("UserDaoProxy.save execute after IUserDao.save....");
}
public static void main(String[] args) {
IUserDao iUserDao = new UserDaoImpl();
UserDaoProxy userDaoProxy = new UserDaoProxy(iUserDao);
//测试
userDaoProxy.save();
}
}
运行结果如下：
UserDaoProxy.save execute before IUserDao.save....
UserDaoImpl.save execute ....
UserDaoProxy.save execute after IUserDao.save....
5.动态代理
1、什么是动态代理
1.代理对象,不需要实现接口
2.代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型)
3.动态代理也叫做:JDK代理,接口代理
2、JDK动态代理
1、原理：是根据类加载器和接口创建代理类（此代理类是InvocationHandler接口的实现类，所以必须使用接口，面向接口生成代理，位于java.lang.reflect包下）
2、实现方式：
通过实现
InvocationHandler接口创建自己的调用处理器IvocationHandler handler = new InvocationHandlerImpl(…);通过为
Proxy类指定ClassLoader对象和一组interface创建动态代理类IUserDao newProxyInstance = (IUserDao) Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
缺点：jdk动态代理，必须是面向接口，目标业务类必须实现接口
3、代码实现
首先建立一个接口IUserDao，一个实现类UserDaoImpl，这一步与静态代理相同，这里不重复黏贴代码。然后建立InvocationHandler的实现类，代码如下。
package com.designpattern.proxy.dynamicproxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* @description: {@link InvocationHandler}实现类，每次生成动态代理类对象时，实现了InvocationHandler接口的调用处理器对象
* @author: Codegitz
* @create: 2020-05-18 12:28
**/
public class InvocationHandlerImpl implements InvocationHandler {
//这是业务实现类对象，用来调用具体的业务方法
private Object target;
//通过构造方法传入
public InvocationHandlerImpl(Object target){
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("start invoke....");
//调用目标对象方法，返回结果
Object invoke = method.invoke(target, args);
System.out.println("finish invoke....");
return invoke;
}
public static void main(String[] args) {
//被代理的对象
IUserDao iUserDao = new UserDaoImpl();
InvocationHandlerImpl invocationHandler = new InvocationHandlerImpl(iUserDao);
ClassLoader classLoader = iUserDao.getClass().getClassLoader();
Class<?>[] interfaces = iUserDao.getClass().getInterfaces();
//主要装载器、一组接口及调用处理动态代理实例
IUserDao newProxyInstance = (IUserDao) Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
System.out.println(newProxyInstance.getClass());
newProxyInstance.save();
}
}
运行结果：
class com.sun.proxy.$Proxy0
start invoke....
UserDaoImpl.save execute....
finish invoke....
3、CGLIB动态代理
1.什么是CGLIB动态代理
原理：利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。 使用cglib[Code Generation Library]实现动态代理，并不要求委托类必须实现接口，底层采用asm字节码生成框架生成代理类的字节码。
使用cglib之前需要引入maven依赖。
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.1</version>
</dependency>
2.CGLIB动态代理代码实现
package com.designpattern.proxy.dynamicproxy.cglibproxy;
import com.designpattern.proxy.dynamicproxy.IUserDao;
import com.designpattern.proxy.dynamicproxy.UserDaoImpl;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/**
* @description: Cglib代理类，实现{@link MethodInterceptor#intercept(Object, Method, Object[], MethodProxy)}
* @author: Codegitz
* @create: 2020-05-18 12:54
**/
public class CglibProxy implements MethodInterceptor {
private Object targetObject;
// 这里的目标类型为Object，则可以接受任意一种参数作为被代理类，实现了动态代理
public Object getInstance(Object target){
// 设置需要创建子类的类
this.targetObject = target;
//工具类
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(target.getClass());
enhancer.setCallback(this);
//创建子类对象代理
return enhancer.create();
}
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("start invoke...");
// 获取代理对象
Object invoke = method.invoke(targetObject, objects);
System.out.println("finish invoke....");
return invoke;
}
public static void main(String[] args) {
CglibProxy cglibProxy = new CglibProxy();
IUserDao iUserDao = (IUserDao) cglibProxy.getInstance(new UserDaoImpl());
System.out.println(iUserDao.getClass());
iUserDao.save();
}
}
运行结果：
class com.designpattern.proxy.dynamicproxy.UserDaoImpl$$EnhancerByCGLIB$$5ffe5b89
start invoke...
UserDaoImpl.save execute....
finish invoke....
附完整代码，需要自取，顺便点个star。
６.CGLIB动态代理与JDK动态区别
java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。而cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。
Spring中：
1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP
2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP
3、如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换
JDK动态代理只能对实现了接口的类生成代理，而不能针对类 。
CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法 。
因为是继承，所以该类或方法最好不要声明成final ，final可以阻止继承和多态。
