java设计模式-代理模式
定义:代理模式给某一个对象提供一个代理对象,并由代理对象控制对原对象的引用。如图
代理模式中的角色:
- 抽象主题角色(Subject):声明了目标对象和代理对象的共同接口,这样一来在任何可以使用目标对象的地方都可以使用代理对象。
- 具体主题角色(RealSubject):也称为委托角色或者被代理角色。定义了代理对象所代表的目标对象。
- 代理主题角色(Proxy):也叫委托类、代理类。代理对象内部含有目标对象的引用,从而可以在任何时候操作目标对象;代理对象提供一个与目标对象相同的接口,以便可以在任何时候替代目标对象。代理对象通常在客户端调用传递给目标对象之前或之后,执行某个操作,而不是单纯地将调用传递给目标对象。
代理模式又分为静态代理和动态代理。
静态代理是由程序猿创建或特定工具自动生成源代码,再对其编译。在程序运行前,代理类的.class文件就已经存在了。在编译前进行增强是我们自己写的
动态代理是在程序运行时,通过运用反射机制动态的创建而成。是不需要我们写代理类的
静态代理
- 代表aspectj
案例1
房东租房子 需要找中介 让中介去找客户 房东只提供租房子的方法 而中介不仅有租房子的方法 还有签合同 还有看房的方法
角色分析:
- 抽象角色:一般会使用接口或者抽象类来解决
- 真实角色:被代理角色
- 代理角色:代理真实角色,代理真实角色后,我们一般会做一些附属操作
- 客户:访问代理对象的人!
代码步骤:
租房接口
//租房
public interface Rent {
//租房
public void rent();
}
2.真实角色房东
//房东
public class Host implements Rent{
@Override
public void rent() {
System.out.println("房东租房子");
}
}
3.代理角色
//中介
public class Proxy implements Rent{
//不用继承方式用组合
private Host host;
public Proxy() {
}
public Proxy(Host host) {
this.host = host;
}
@Override
public void rent() {
host.rent();
this.price();
this.hetong();
}
//中介费
public void price(){
System.out.println("中介收中介费");
}
//合同
public void hetong(){
System.out.println("中介签合同");
}
}
4.客户端访问代理角色
//房东要租房子
Host host=new Host();
//代理,中介帮房东租房子, 中介还会附加一些其他的操作
Proxy proxy=new Proxy(host);
//你不用直接面对房东 直接找中介操作
proxy.rent();
结果
案例2
原有的增删改查接口 需要添加日志功能
在公司不能改变原有的业务代码 ,改动原有代码在公司是大忌!
增删改查接口
public interface UserService {
void add();
void dele();
void update();
void slect();
}
具体实现类 如果需要添加日志 不能改动原有的代码
public class UserServiceImpl implements UserService{
@Override
public void add() {
System.out.println("add");
}
@Override
public void dele() {
System.out.println("dele");
}
@Override
public void update() {
System.out.println("update");
}
@Override
public void slect() {
System.out.println("slect");
}
}
每次运行方法都需要添加日志接口 又不能改变原有代码
使用代理类来解决
用代理类实现同样的接口。
//在每个方法中加入日志功能
public class UserServiceProxy implements UserService {
private UserServiceImpl userService;
public void setUserService(UserServiceImpl userService) {
this.userService = userService;
}
@Override
public void add() {
log("add");
userService.add();
}
@Override
public void dele() {
log("dele");
userService.dele();
}
@Override
public void update() {
log("update");
userService.update();
}
@Override
public void slect() {
log("slect");
userService.slect();
}
public void log(String msg){
System.out.println("打印了"+msg+"日志");
}
}
代理的对象拥有一样的方法 对方法进行添加日志方法。
测试类
public static void main(String[] args) {
UserServiceImpl userService=new UserServiceImpl();
UserServiceProxy proxy=new UserServiceProxy();
proxy.setUserService(userService); //将被代理类组合进来
proxy.add();
proxy.dele();
proxy.slect();
}
运行结果
代理模式的好处:
- 可用使真实角色的操作更加纯粹!不用去关注一些公共的业务
- 公共也就交给代理角色!实现了业务的分工!
- 公共业务发生扩展的时候,方便集中管理
缺点:
- 一个真实角色就会产生一个代理角色;代码量会翻倍 开发效率会变低
要是每一个代理类都产生一个代理角色 这样代码量太多了 我们要怎么解决呢
->为了解决这个问题 我们使用动态代理
动态代理
- 动态代理和静态代理角色一样
- 动态代理的代理类是我们动态生成的,不是我们直接写好的
- 动态代理分为两大类:基于接口的动态代理,基于类的动态代理
- 基于接口—JDK动态代理
- 基于类: cglib
- java字节码实现: javasist
需要了解两个类:
Proxy:提供了创建动态代理类和实例的静态方法 static 可用直接调用proxy.方法
接口 invocationHandler:调用处理程序 处理代理实例并返回结果
传入的invocationHandler接口 是 实现类 重写的invoke方法会进行增强
我们可以直接new 然后用匿名内部类的方式 只需要重写invoke接口 invoke接口
接口实现的invoke方法 执行代理类的每一个方法都会经过invoke方法
我们继续将上面的例子使用动态代理
首先先是一个接口 有一个租房功能
public interface cent {
void cent();
}
房东
public class host implements cent{
@Override
public void cent() {
System.out.println("房东卖房子");
}
}
生成代理类的方法
public class proxy1 implements InvocationHandler {
private cent host;
public void setTarget(cent host) {
this.host = host;
}
//得到生成的代理类
public Object getProxy(){
/**
* Proxy.newProxyInstance(目标代理类的类加载器,目标代理类的接口,InvocationHandler接口)
* InvocationHandler:用于实现增强的方法 接口内 主要实现invoke方法 每使用一次方法都会经过invoke
*/
Object ProxyTarget = Proxy.newProxyInstance(host.getClass().getClassLoader(),
host.getClass().getInterfaces(), this);
return ProxyTarget;
}
/**
* 处理代理实例,并返回结果
* 每次目标代理类的对象调用方法 都会经过下面的方法进行增强
* 这个方法是 实现了InvocationHandler接口中重写的方法
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//日志方法
hetong();
Object invoke = method.invoke(host, args);
return invoke;
}
public void hetong(){
System.out.println("签合同");
}
}
测试
public static void main(String[] args) {
//真实角色
host host=new host();
//组合目标代理对象
proxy1 proxy1=new proxy1(); //该类实现了invocationhandler类
proxy1.setTarget(host);
cent proxyhost = (cent) proxy1.getProxy(); //获得目标代理类的对象
//使用代理类来租房子
proxyhost.cent();
我们也可以写一个通用的返回代理类的方法
参数为Obj 只需要传入 被代理类的方法 在invoke写需要增强的代码即可
动态代理好处:
- 可用使真实角色的操作更加纯粹!不用去关注一些公共的业务
- 公共也就交给代理角色!实现了业务的分工
- 公共业务发生扩展,方便集中管理
- 一个动态代理类代理的是一个接口,一般就是对应一个业务
- 一个动态代理可用代理多个类,只要是实现了同一个接口即可
面试题
JDK动态代理和Cglib动态代理的区别
SrpingAop中的动态代理有2种,一种是JDK的动态代理,另一种是Cglib的动态代理
-
JDK动态代理只提供接口的代理,不支持类的代理。核心InvocationHandler接口和Proxy类,InvocationHandler 通过invoke()方法反射来调用目标类中的代码,动态地将横切逻辑和业务编织在一起;接着,Proxy利用 InvocationHandler动态创建一个符合某一接口的的实例, 生成目标类的代理对象。
-
如果代理类没有实现 InvocationHandler 接口,那么Spring AOP会选择使用CGLIB来动态代理目标类。CGLIB(Code Generation Library),是一个代码生成的类库,可以在运行时动态的生成指定类的一个子类对象,并覆盖其中特定方法并添加增强代码,从而实现AOP。CGLIB是通过继承的方式做的动态代理,因此如果某个类被标记为final,那么它是无法使用CGLIB做动态代理的。
静态代理与动态代理区别在于生成AOP代理对象的时机不同,相对来说AspectJ的静态代理方式具有更好的性能,但是AspectJ需要特定的编译器进行处理,而Spring AOP则无需特定的编译器处理。
InvocationHandler 的 invoke(Object proxy,Method method,Object[] args):proxy是最终生成的代理实例; method 是被代理目标实例的某个具体方法; args 是被代理目标实例某个方法的具体入参, 在方法反射调用时使用。