设计模式java-04.代理模式

java的三种代理模式
代理模式提供了对目标对象的另外的访问方式,即通过代理对象访问目标对象。这样做的好处是尅在目标对象实现的基础上,增强额外的操作功能,即扩张目标对象的功能。
举个栗子来说明代理的作用:假如我们想买辆车,那么并不是直接找汽车生产厂家,而是找4S店(四儿子),来达到同样买车的目的。这里的车就是一个目标对象,厂家只要负责生产车,而其他的事情就交由厂家的代理4S店来完成。

一,静态代理
静态代理在使用时需要定义接口或者父类,被代理对象和代理对象一起实现相同的接口或者是继承相同的父类。
下面还是以消费者买车为例子来解释:
汽车生产厂家要卖车,但是不是自己直接卖,而是交由4S店来卖:
这样我们定义一个卖车的接口

public interface IBaseSaleCar{
    void saleCar();
}

汽车生产厂家来实现这个接口,它要把车卖出去:

public class CarFactorySale implements IBaseSaleCar{
    @Override
    public void saleCar(){
        System.out.println("卖我(汽车厂家)生产的车");
    }

}

接下来4S店来代理卖汽车厂家生产的车了:

public class FourShopSaleCar implements IBaseSaleCar{
    private IBaseSaleCar target;
    public FourShopSaleCar(IBaseSaleCar target){
        this.target = target;
    }
    @Override
    public void saleCar(){
        target.saleCar();
    }

}

我们来测试下代码:

public class TestProxy{
    public static void main(String[] args){
        CarFactorySale target = new CarFactorySale();
        FourShopSaleCar proxy = new FourShopSaleCar(target);
        proxy.saleCar();
    }
}

这样就是一个完整的静态代理的例子,通过FourShopSaleCar来间接完成卖车的动作,接下来我们看看4S店是怎么揩油加价的,为了方便我们引入一个Car对象;

public class Car {

    /**品牌 */
    private String brand;

    /** 价格  */
    private Long price;

    public Car(String brand, Long price){
        this.brand = brand;
        this.price = price;
    }

    public Long getPrice() {
        return price;
    }

    public void setPrice(Long price) {
        this.price = price;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String toString(){
        return "我卖"+this.brand+"牌子的车,我卖"+this.price+"块钱";
    }

}
public interface IBaseSaleCar {
    void saleCar(Car car);
}
public class CarFactorySale implements IBaseSaleCar{

    @Override
    public void saleCar(Car car){
        System.out.println(car.toString());
    }

}

4S店加价出售

public class FourShopSaleCar implements IBaseSaleCar{
    private IBaseSaleCar target;
    public FourShopSaleCar(IBaseSaleCar target){
        this.target = target;
    }
    @Override
    public void saleCar(Car car){
        //加了200块
        car.setPrice(car.getPrice() + 200L);
        target.saleCar(car);
    }
}

然后就卖出去了

    public class TestProxy{
        public static void main(String[] args){
            //厂家定价1000块
            Car car = new Car("Benz", 1000L);
            CarFactorySale target = new CarFactorySale();
            FourShopSaleCar proxy = new FourShopSaleCar(target);
            //4S店卖的时候偷偷加了200块
            proxy.saleCar(car);
        }
    }

执行结果,多买了200块,多卖的这两百块就是代理模式的好处了,可以在卖车前和卖车后做做手脚,搞搞其他的事情,赚钻外快什么的。

我卖Benz牌子的车,我卖1200块钱

这个就是静态代理了,下面我们了解下动态代理。静态代理的缺点就是需要实现目标对象接口方法,也就是这里的FourShopSaleCar.saleCar方法。

二,动态代理
动态代理一般分为使用jdk自带api来处理,和使用cglib来代理两种模式。
动态代理的特点就是不需要实现目标对象的接口方法,主要使用到了java.lang.reflect.Proxy类中的newProxyInstance方法。
这个方法有三个参数:
ClassLoader loader指定当前目标对象使用类加载器,获取加载器的方法是固定的
Class<> interfaces目标对象实现的接口的类型,使用泛型方式确认类型
InvocationHandler h 事件处理,执行目标对象的方法时,会触发事件处理器的方法,会把当前执行目标对象的方法作为参数传入
让我们来创建一个代理工厂类:

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyFactory {
    //要代理的对象
    private Object target;

    public ProxyFactory(Object target){
        this.target = target;
    }

    public Object getProxyFactoryInstance(){
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler(){
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
                        Object returnValue = method.invoke(target, args);
                        return returnValue;
                    }
                });
    }
}

测试一下我们的代理工厂类:

public class ProxyTest {
    public static void main(String[] args){
        Car car = new Car("BMW", 1000L);
        IBaseSaleCar target = new CarFactorySale();
        System.out.println(target.getClass());
        IBaseSaleCar proxy = (IBaseSaleCar) new ProxyFactory(target).getProxyFactoryInstance();
        System.out.println(proxy.getClass());
        proxy.saleCar(car);

    }
}

执行结果

class com.test.CarFactorySale
class com.sun.proxy.$Proxy0
我卖BMW牌子的车,我卖1000块钱

这里我们已经不需要像静态代理中的FourShopSaleCar一样来实现IBaseSaleCar中的saleCar接口了。这个就是动态代理的优势了。

三、cglib动态代理

jdk动态代理只能针对实现了接口的类,一般没有实现接口的类不能代理。cglib就是针对类来实现代理的,它的原理是针对指定目标类生成一个子类,并覆盖其方法增强其实现。因为采用的是继承,因此不能针对final修饰的类进行代理。使用cglib进行动态代理,完全不受代理类必须实现接口的限制,而且cglib底层使用ASM字节码生成框架,使用字节码技术生成代理类,比java反射的效率要高。

下面来看个例子:
使用cglib动态代理我们需要引入2个包:cglib.jar,asm.jar
定义了一个拦截器,在调用目标方法之前,cglib回调MethodInterceptor接口方法拦截,来实现自己的业务逻辑,类似
于JDK中的InvocationHandler接口。

public class UserDaoImpl {  

    public void save() {  
        System.out.println("Mysql执行保存...");  
    }  

}  
import java.lang.reflect.Method;  
import net.sf.cglib.proxy.Enhancer;  
import net.sf.cglib.proxy.MethodInterceptor;  
import net.sf.cglib.proxy.MethodProxy;  

public class CglibProxyFactory {  

    private Object obj;  

    public CglibProxyFactory(Object obj) {  
        super();  
        this.obj = obj;  
    }  

    public Object getProxyFactory(){  
        //Enhancer类是cglib中的一个字节码增强器,它可以方便的为你所要处理的类进行扩展  
        Enhancer enhancer = new Enhancer();  
        enhancer.setSuperclass(obj.getClass());//将目标对象所在的类作为Enhaner类的父类  
        enhancer.setCallback(new MethodInterceptor() {  
            //通过实现MethodInterceptor实现方法回调  
            @Override  
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {  
                System.out.println("事务开启...");  
                method.invoke(obj, args);  
                System.out.println("事务结束...");  
                return proxy;  
            }  
        });  

        return enhancer.create();//生成目标对象并返回  
    }  
}  
public class TestCglibProxy {   
    public static void main(String[] args){  
        UserDaoImpl userDao = new UserDaoImpl();  
        UserDaoImpl userDaoProxy = (UserDaoImpl) new CglibProxyFactory(userDao).getProxyFactory();  
        userDaoProxy.save();  
        System.out.println("目标对象类型:"+userDao.getClass());  
        System.out.println("代理对象类型:"+userDaoProxy.getClass());  
    }  
}  

参考:https://www.cnblogs.com/cenyu/p/6289209.html

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值