java代理

最近看spring了解了代理模式，又开始看代理。全是概念性的东西，有些杂乱，整理一下收获。

代理的概念

一种设计模式，调用访问的时候访问代理对象，不直接访问被代理对象（目标对象，就是具体执行业务的类）

好处

隐藏了被代理类的实现，之和代理类交互就行，这样解耦，可以添加一下公共操作

什么场景用

• 在执行原来方法之前和之后执行一些操作，记录log，事务控制
• 封装隐藏真实的业务类，隐藏业务逻辑，只暴漏接口给调用者
• SpringAOP
• Mybatis也用了
  https://www.cnblogs.com/wolf-zt/p/7237866.html
  https://blog.csdn.net/xiaokang123456kao/article/details/76228684

实现种类

静态代理

特点：代码编译时就确定了被代理的类是谁
场景举例：卖家 买家 中介
接口：

public interface Sale {

    boolean check();

    boolean sale(boolean checked);

}

实际业务

public class Owner implements Sale {

    private int max = 100000;

    @Override
    public boolean check() {
        boolean good = random(0.6);
        if (good) {
            System.err.println("Owner implements Sale-check()：客户看房，看好！");
        } else {
            System.err.println("Owner implements Sale-check()：客户看房，未看好！");
        }
        return good;
    }

    @Override
    public boolean sale(boolean checked) {
        double per = 0.5;
        if (checked) {
            per = 0.9;
            System.err.println("Owner implements Sale-sale()：客户买房，看好！");
        } else {
            per = 0.1;
            System.err.println("Owner implements Sale-sale()：客户买房，未看好！");
        }
        boolean sold = random(per);
        if (sold) {
            System.err.println("Owner implements Sale-sale()：客户买房，卖出！");
        } else {
            System.err.println("Owner implements Sale-sale()：客户买房，未卖出！");
        }
        return sold;
    }

    private boolean random(double truePer) {
        Random random = new Random();
        int ran = random.nextInt(max);
        if (ran < (max * truePer)) {
            return true;
        }
        return false;
    }
}

代理

public class Agent implements Sale {
    private Owner owner;

    public Agent() {
    }

    @Override
    public boolean check() {
        // TODO Auto-generated method stub
        return false;
    }

    @Override
    public boolean sale(boolean checked) {
        // TODO Auto-generated method stub
        return false;
    }

    private Owner getOwner() {
        if (owner == null) {
            owner = new Owner();
        }
        return owner;
    }
}

交易

public class Customer {
    public static void main(String[] args) {
        Sale sale = new Agent();
        boolean checked = sale.check();
        sale.sale(checked);
    }
}

优点：业务类只关注业务，保证业务类的重用
缺点：因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多.同时,一旦接口增加方法,目标对象与代理对象都要维护.

动态代理

jdk动态代理

特点：不确定被代理的类，代码运行时再加载被代理类
核心类：

• InvocationHandler 接口
  1.代理类和被代理类的中间类必须实现的接口，他有一个invoke方法，用这个方法实现对被代理类的调用
  2.核心方法，invoke(Object proxy, Method method, Object[] args)
  proxy代理类的实例
  method被调用的方法
  args参数
• Proxy类
  1.代理对象，接口不能实例化，所以他去实例化接口的方法并代理
  2.核心方法getInvocationHandler
  getProxyClass
  isProxyClass
  newProxyInstance生成代理对象
  理解：
  在生成的动态代理类$Proxy0.class中，构造方法调用了父类Proxy.class的构造方法，给成员变量invocationHandler赋值，$Proxy0.class的static模块中创建了被代理类的方法，调用相应方法时方法体中调用了父类中的成员变量InvocationHandler的invoke()方法

/**
 * 创建动态代理对象
 * 动态代理不需要实现接口,但是需要指定接口类型
 */
public class ProxyFactory{

    //维护一个目标对象
    private Object target;
    public ProxyFactory(Object target){
        this.target=target;
    }

   //给目标对象生成代理对象
    public Object getProxyInstance(){
        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("开始事务2");
                        //执行目标对象方法
                        Object returnValue = method.invoke(target, args);
                        System.out.println("提交事务2");
                        return returnValue;
                    }
                }
        );
    }

}

/**
 * 测试类
 */
public class App {
    public static void main(String[] args) {
        // 目标对象
        IUserDao target = new UserDao();
        // 【原始的类型 class cn.itcast.b_dynamic.UserDao】
        System.out.println(target.getClass());

        // 给目标对象，创建代理对象
        IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
        // class $Proxy0   内存中动态生成的代理对象
        System.out.println(proxy.getClass());

        // 执行方法   【代理对象】
        proxy.save();
    }
}

代理对象不需要实现接口,但是目标对象一定要实现接口,否则不能用动态代理

cglib动态代理

特点：不整接口了，我直接弄个弄个子类继承被代理的类，这就不要求代理对象实现接口了。不过代理类属性要是final那就没招了。
核心类

• MethodInterceptor接口，类似InvocationHandler的作用
  intercept(Object obj, Method method, Object[] args, MethodProxy proxy)
  obj代理类实例
  method执行方法
  args参数
  proxy调用方法的代理对象实例
• Enhancer类
  setSuperclass设置父类
  setCallback设置回调函数
  create创建子类(代理对象)

/**
 * 目标对象,没有实现任何接口
 */
public class UserDao {

    public void save() {
        System.out.println("----已经保存数据!----");
    }
}

/**
 * Cglib子类代理工厂
 * 对UserDao在内存中动态构建一个子类对象
 */
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("提交事务...");

        return returnValue;
    }
}

/**
 * 测试类
 */
public class App {

    @Test
    public void test(){
        //目标对象
        UserDao target = new UserDao();

        //代理对象
        UserDao proxy = (UserDao)new ProxyFactory(target).getProxyInstance();

        //执行代理对象的方法
        proxy.save();
    }
}