设计模式之代理模式

代理模式(静态代理和动态代理)

代理模式:我觉得就是类似于Spring AOP,在不改变原有类的情况下，给某个方法的调用加一些条件。

代理总结(一):就是利用共同实现一个接口，如下例子，租房的人和中介都实现了一个接口，所以它们都有接口IRent中的rent方法,在中介Medium类中定义共同接口类型的字段private IRent rent;然后再构建一个构造器添加一个IRent类型的形参传参入口(IRent rent)

　　　　　　调用方法的时候，先new出租房人的对象实例IRent target = new Gerry();，命名为target,这个target实现了IRent接口,所以它就是 IRent类型的target,它就可以作为参数传给new Medium(IRent rent) 中的rent(target)。

　　　　　　IRent proxy = new Medium(target);　 然后prox.rentHouse(); 这里调用的是接口中IRent中的rentHouse();但是因为多态，会调用创建实例的时候子类(接口的实现类)中自己重写的方法,这里proxy(Medium的实例).rentHouse();调用的是Medium中介类中的方法,而中介中的rentHouse方法里的语句是rent.rentHouse();这里的rent就是上面构造器中this.rent = rent(target)传参后的target,就是Gerry的对象实例,所以就又调用Gerry中的rentHouse();了，总而实现了代理效果。在中介Medium类的rentHouse();方法中rent.rentHouse();方法执行前可以添加任意认证要求,这种功能就像是springAOP中的功能一样不是么。

　　　　总之【核心是多态我觉得】：就是必须的实现同一个接口,这样才可以有IRent target = new Gerry();这种形式，从而有IRent proxy = new Medium(target);→proxy.rentHouse(); (rent(this.rent = rent(target).renHouse(); )   →   target.rentHouse();

　　　　说了这么多都把自己说晕了感觉...看来还是没理解透彻，

代理总结(二):第二个(动态代理)我觉得换汤不换药,就是动态生成代理对象而已(利用传参把请求方的实现的所有接口组成的数组传进来,然后底层让"中介"实现它们，这样就又达到了使它们实现同一个借口的目的，从而又回到了静态代理的板子。)

一、静态代理（租房子）:

　　gerry需要租房子,中介帮他找房子,双方都得实现一个协议-IRent接口

　　中介类中找到需要租房子的人，IRent rent;通过构造函数把传进来的租房人给rent,再用rent调用方法

package deep.staticc.demo;

public interface IRent {

    public void rentHouse(String name);
}

package deep.staticc.demo;



/**
 * 场景:gerry工作非常忙,没有时间找房子,需要找一个中介帮忙
 * @author DeepSleeping
 *
 */
public class Gerry implements IRent{
    
    @Override
    public void rentHouse(String name){
        System.out.println(name + "需要租房子");
    }
}

package deep.staticc.demo;

public class Medium implements IRent {

    //持有目标代理类的引用
    private IRent rent;
    
    public Medium(IRent rent){
        this.rent = rent;
    }

    
    @Override
    public void rentHouse(String name) {
        rent.rentHouse(name);
    }

}

package deep.staticc.demo;

public class TestProxy {
    public static void main(String[] args) {
        //创建目标对象
        IRent target = new Gerry();
        //创建一个代理对象
        IRent proxy = new Medium(target);
        //通过代理调用方法
        proxy.rentHouse("gerry");
    }
}

静态代理总结:局限性太大,只有共同实现了某一个接口才能够代理,即都实现了IRent接口通过多态来运转。

二、动态代理(添加信息前进行权限认证)

package deep.dynamic.demo;

public interface IUserDao {

    void add();
    
    void deletd();

}

package deep.dynamic.demo;

/**
 * 实现认证操作功能：
 * 项目中每一个方法的调用都需要进行4个认证
 * 1、是否合法
 * 2、是否有新增权限
 * 3、开启事务
 * 4、关闭事务
 * @author DeepSleeping
 *
 */
public class UserDaoImpl implements IUserDao {
    
    @Override
    public void add(){
        System.out.println("新增信息");
    }

    @Override
    public void deletd() {
        System.out.println("删除信息");
        
    }
}

package deep.dynamic.demo.proxy;

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

/**
 * 动态代理类
 * @author DeepSleeping
 *
 */
public class ProxyClass {
    //目标对象
    private Object target;
    
    public ProxyClass(Object target){
        this.target = target;
    }
    
    /**
     * 创建当前目标对象代理对象
     * @return
     */
    public Object createProxy(){
        /**
         * loader:目标对象的类加载器
         * interfaces:目标对象实现的所有接口组成的数组
         * handler:定义一个调用目标类中方法的回调类
         */
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),
                new InvocationHandler() {
                    
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //进行调用前的认证
                        System.out.println("1、是否合法");
                        System.out.println("2、是否有权限");    
                        System.out.println("3、开启事务");
                        Object obj = null;
                        
                        
                        try {
                            method.invoke(target, args);
                            
                        } catch (Exception e) {
                            System.out.println("4、关闭事务");
                        }    
                        System.out.println("--业务执行正常--");
                        
                        return obj;
                    }
                });
    }
}

package deep.dynamic.demo;

import deep.dynamic.demo.proxy.ProxyClass;

public class TestDynamicProxy {

    public static void main(String[] args) {
        //创建目标对象
        IUserDao target = new UserDaoImpl();
        //创建代理类的实例
        ProxyClass proxy = new ProxyClass(target);
        //生成对应的代理对象
        IUserDao userDao = (IUserDao) proxy.createProxy();
        userDao.add();
        userDao.deletd();
    }
}

 附加:为什么可以强转IUserDao userDao = (IUserDao) proxy.createProxy();

　　是因为Proxy.newProxyInstance方法的第二个参数取得了目标对象的所有实现的接口的数组,代理对象就会实现这组接口,所以我们就可以将代理对象任意强转成这组接口的任意一个。

静态代理:共同实现一个接口,通过多态调用

动态代理:动态地实现同一个接口(通过方法传目标对象实现过的接口,然后底层自动实现它们,这样就像静态代理那样，目标和代理对象都实现了同一个接口)然后又可以利用多态强转后调用