代理模式
代理模式（proxy）：为其他对象提供一个代理以控制对这个对象的访问。
主要解决：在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。
代理模式的元素是：共同接口、代理对象、目标对象。
代理模式的行为：由代理对象执行目标对象的方法、由代理对象扩展目标对象的方法。
代理模式的宏观特性：对客户端只暴露出接口，不暴露它以下的架构。
好处多多：中间隔离了一层，更加符合开闭原则
uml图
创建一个接口
/**
* @author: promsing
* @date: 2021/4/3 - 8:25
* @description: 买车的接口
* @version： 1.0
*/
public interface buycar {
public void buycar();
}
创建一个实现类
/**
* @author: promsing
* @date: 2021/4/3 - 8:25
* @description: 实现类
* @version： 1.0
*/
public class buycarimpl implements buycar {
@override
public void buycar() {
system.out.println("我要买车~~~啦啦啦");
}
}
静态代理：
创建一个代理类
/**
* @author: promsing
* @date: 2021/4/3 - 8:26
* @description: 代理类
* @version： 1.0
*/
public class buycarproxy implements buycar{
private buycar buycar;
//注意事final修饰的关键字 不可修改
//构造函数注入，需要被代理的对象
public buycarproxy(final buycar buycar) {
this.buycar = buycar;
}
//静态代理- 的实现方式
@override
public void buycar() {
system.out.println("不贷款，全款！买车前的准备~~~");
buycar.buycar();
system.out.println("买完车了，出去浪~~~");
}
}
客户端调用
/**
* @author: promsing
* @date: 2021/4/3 - 8:36
* @description: 客户端调用
* @version： 1.0
*/
public abstract class proxytest implements buycar {
public static void main(string[] args) {
system.out.println("-+-+-+正常调用-+-+-+");
buycar car=new buycarimpl();
car.buycar();
system.out.println("-+-+-+使用静态代理-+-+-+");
buycar proxy=new buycarproxy(car);
proxy.buycar();
}
}
-+-+-+正常调用-+-+-+
我要买车~~~啦啦啦
-+-+-+使用静态代理-+-+-+
不贷款，全款！买车前的准备~~~
我要买车~~~啦啦啦
买完车了，出去浪~~~
动态代理：
基于接口的动态代理类
特点：字节码随用随创建，随用随加载
作用：在不修改源码的基础上对方法增强
涉及的类：jdk官方提供的proxy
如何创建代理对象：使用proxy类中的newproxyinstance方法
创建代理对象的要求：被代理类至少实现一个接口
newproxyinstance方法的参数
classloader：类加载器，同于加载被代理对象字节码
class[]：字节码数组—用于让代理对象和被代理对象拥有相同的方法
invocationhandler：用于提供被增强的代码
/**
* @author: promsing
* @date: 2021/4/3 - 9:09
* @description: 描述 形容
* @version： 1.0
*/
public class dynamicproxy implements invocationhandler {
private buycar object;
public dynamicproxy( buycar object) {
this.object = object;
}
/**
*
* @param proxy 代理对象的引用
* @param method 当前执行的方法
* @param args 当前执行方法所需的参数
* @return 和被代理对象方法有相同的返回值
* @throws throwable
*/
@override
public object invoke(object proxy, method method, object[] args) throws throwable {
system.out.println("不贷款，全款！买车前的准备~~~");
object result = method.invoke(object, args);
system.out.println("买完车了，出去浪~~~");
return result;
}
}
客户端
public static void main(string[] args) {
system.out.println("-+-+-+使用基于接口的代理-+-+-+");
//方式一、如不写动态代理类dynamicproxy，可以在这里使用内部类
//声明一个final修饰的对象
/*
final buycarimpl car=new buycarimpl();
buycar proxy=(buycar)proxy.newproxyinstance(car.getclass().getclassloader(), car.getclass().getinterfaces(), new invocationhandler() {
@override
public object invoke(object proxy, method method, object[] args) throws throwable {
system.out.println("不贷款，全款！买车前的准备~~~");
object result = method.invoke(car, args);
system.out.println("买完车了，出去浪~~~");
return result;
}
});
proxy.buycar();
*/
//方式二、使用dynamicproxy类
//声明一个final修饰的对象
final buycarimpl car=new buycarimpl();
buycar proxy=(buycar)proxy.newproxyinstance(car.getclass().getclassloader(), car.getclass().getinterfaces(),new dynamicproxy(car));
proxy.buycar();
}
基于子类的动态代理
特点：字节码随用随创建，随用随加载
作用：在不修改源码的基础上对方法增强
涉及的类：第三方cglib提供的enhancer
如何创建代理对象：使用enhancer类中create方法
创建代理对象的要求：被代理类不能是最终类
newproxyinstance方法的参数
class：用于被指定代理对象的字节码
invocationhandler：用于提供增强的方法
public static void main(string[] args) {
//使用基于子类的动态代理
//需要引入jar包--cglib 本案例使用cglib3.3.0
system.out.println("-+-+-+使用基于子类的代理-+-+-+");
final buycarimpl car=new buycarimpl();
buycar proxy= (buycar)enhancer.create(car.getclass(), new methodinterceptor() {
@override
public object intercept(object o, method method, object[] objects, methodproxy methodproxy) throws throwable {
system.out.println("不贷款，全款！买车前的准备~~~");
object result = method.invoke(car, args);
system.out.println("买完车了，出去浪~~~");
return result;
}
});
proxy.buycar();
}
总结
到此这篇关于java静态代理和动态代理的文章就介绍到这了,更多相关java静态代理和动态代理内容请搜索www.887551.com以前的文章或继续浏览下面的相关文章希望大家以后多多支持www.887551.com！
