一、java中的代理模式
代理（Proxy）模式提供了对目标对象的间接访问模式，可在不修改目标类的情况下，扩展功能。
这里以保存用户数据的方式进行简要说明。
简单图示：
初始.jpg
现在我们期望在保存用户数据之前打印一下日志，我们可以有以下两种方式实现
1.1 静态代理
简单图示：
静态代理.png
代码示例：
IUserDao.java
/**
* 目标对象与代理对象共同实现的接口
*/
public interface IUserDao {
// 代理对象
void save();
}
UserDao.java
/**
* 目标对象，即被代理的对象
*/
public class UserDao implements IUserDao{
@Override
public void save() {
System.out.println("==保存用户数据==");
}
}
UserDaoProxy.java
/**
* 代理对象，使用时用以替换目标对象
*/
public class UserDaoProxy implements IUserDao{
IUserDao userDao;
/**
* 以构造方法注入 目标对象userDao，
* 内部用共同的实现接口接收
*/
UserDaoProxy(IUserDao userDao){
this.userDao = userDao;
}
@Override
public void save() {
System.out.println("==打印日志==");
userDao.save();
}
}
这里用main方法模拟UserService
/**
* 测试方法
*/
public static void main(String[] args){
// 目标对象
IUserDao userDao = new UserDao();
// 代理对象
UserDaoProxy proxy = new UserDaoProxy(userDao);
// 代理方法
proxy.save();
}
静态代理小结：
一个接口需要实现一个代理类，这样在实际业务中，会产生大量的类，难以维护。
1.2 动态代理
简单图示：
动态代理.png
代码示例：
IUserDao.java
public interface IUserDao {
void save();
}
UserDaoProxy.java
/**
* 代理类
*/
public class UserDaoProxy {
private Object target;
public UserDaoProxy(Object object){
target = object;
}
public Object getProxyInstance(){
Object obj = null;
// 代理对象由哪一个类加载器负责加载
ClassLoader loader = target.getClass().getClassLoader();
// 代理对象的类型，即其中有哪些方法
Class[] interfaces = target.getClass().getInterfaces();
// 代理对象执行对象方法时，执行这里
InvocationHandler handler = new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
try {
// 前置通知
System.out.println("前置通知: method:"+ method.getName()+" with "+ Arrays.toString(args));
result = method.invoke(target,args);
// 返回通知
System.out.println("返回通知： result:"+result);
}catch (Exception e){
e.printStackTrace();
// 异常通知
System.out.println("异常通知："+e);
}
// 后置通知
System.out.println("后置通知。。。");
return result;
}
};
obj = Proxy.newProxyInstance(loader,interfaces,handler);
return obj;
}
测试代码：
public static void main(String[] args){
//目标对象
IUserDao target = new UserDao();
// 动态代理,这里必须用接口接收
IUserDao proxy = (IUserDao) new UserDaoProxy(target).getProxyInstance();
proxy.save();
System.out.println("=========================");
}
动态代理小结：
1.代理对象,不需要实现接口
2.代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型)
3.动态代理也叫做:JDK代理,接口代理
4.代理对象不需要实现接口,但是目标对象一定要实现接口,否则不能用动态代理
代理类(studentProxy)是自己定义好的，在程序运行之前就已经编译完成。然而动态代理，代理类并不是在Java代码中定义的，而是在运行时根据我们在Java代码中的“指示”动态生成的。相比于静态代理， 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。
二、cglib实现代理
当目标对象未实现任何接口而需要用到代理模式时，可以使用cglib。
Cglib代理,也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展.
- JDK的动态代理有一个限制,就是使用动态代理的对象必须实现一个或多个接口,如果想代理没有实现接口的类,就可以使用Cglib实现.
- Cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口.它广泛的被许多AOP的框架使用,例如Spring AOP和synaop,为他们提供方法的interception(拦截)
- Cglib包的底层是通过使用一个小而块的字节码处理框架ASM来转换字节码并生成新的类.不鼓励直接使用ASM,因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉.
简单图示：
代码示例：
UserDao.java
public class UserDao {
public void save() {
System.out.println("save..");
}
}
ProxyFactory.java
/**
* cglib实现aop
*/
public class ProxyFactory implements MethodInterceptor {
//维护目标对象
private Object target;
public ProxyFactory(Object target) {
this.target = target;
}
//给目标对象创建一个代理对象
public Object getProxyInstance(){
//1.工具类
Enhancer en = new Enhancer();
//2.设置父类
en.setSuperclass(target.getClass());
//3.设置回调函数
en.setCallback(this);
//4.创建子类(代理对象)
return en.create();
}
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("开始事务...");
//执行目标对象的方法
Object returnValue = method.invoke(target, args);
System.out.println(returnValue);
System.out.println("提交事务...");
return returnValue;
}
}
测试代码
public static void main(String[] args){
// cglib实现
UserDao proxy1 = (UserDao)new ProxyFactory(target).getProxyInstance();
//执行代理对象的方法
proxy1.save();
}
参考：https://www.cnblogs.com/cenyu/p/6289209.html