java之静态代理和动态代理

静态代理

这里有一个程序员接口，他们每天就是写代码

public interface Programmer {

    // 程序员每天都写代码
    void coding();

}

Java3y也是一个程序员，他也写代码(每个程序员写的代码都不一样，所以分了接口和实现类)

public class Java3y implements Programmer {

    @Override
    public void coding() {
        System.out.println("Java3y最新文章：......给女朋友讲解什么是代理模式.......");
    }
}

程序员大V会每次让Java3y发文章时，就给Java3y点赞、评论、鼓吹这文章好。只要流量有了，钱就到手了。

• 1、实现与被增强对象相同的接口
• 2、定义一个变量记住被增强对象
• 3、定义一个构造器，接收被增强对象
• 4、覆盖需要增强的方法
• 5、对于不想增强的方法，直接调用被增强对象（目标对象）的方法

public class ProgrammerBigV implements Programmer {
    
    // 指定程序员大V要让谁发文章(先发文章、后点赞)
    private Java3y java3y ;

    public ProgrammerBigV(Java3y java3y) {
        this.java3y = java3y;
    }

    // 程序员大V点赞评论收藏转发
    public void upvote() {
        System.out.println("程序员大V点赞评论收藏转发！");
    }

    @Override
    public void coding() {

        // 让Java3y发文章
        java3y.coding();

        // 程序员大V点赞评论收藏转发！
        upvote();
    }
}

文章(代码)还是由Java3y来发，但每次发送之后程序员大V都会点赞。

public class Main {

    public static void main(String[] args) {

        // 想要发达的Java3y
        Java3y java3y = new Java3y();

        // 受委托程序员大V
        Programmer programmer = new ProgrammerBigV(java3y);

        // 受委托程序员大V让Java3y发文章，大V(自己)来点赞
        programmer.coding();
    }  
}

ProgrammerBigV就是代理类，java3y就是被代理类

基于接口的动态代理 Proxy.newProxyInstance

InvocationHandler的invoke方法

此处我们使用的是一个演员的例子：
在很久以前，演员和剧组都是直接见面联系的。没有中间人环节。
而随着时间的推移，产生了一个新兴职业：经纪人（中间人），这个时候剧组再想找演员就需要通过经纪
人来找了。下面我们就用代码演示出来。
/**
* 一个经纪公司的要求:
* 能做基本的表演和危险的表演
*/
public interface IActor {
/**
* 基本演出
* @param money
*/
public void basicAct(float money);
/**
* 危险演出
* @param money
*/
public void dangerAct(float money);
}

/**
* 一个演员
*/
//实现了接口，就表示具有接口中的方法实现。即：符合经纪公司的要求
public class Actor implements IActor{
public void basicAct(float money){
System.out.println("拿到钱，开始基本的表演："+money);
}
public void dangerAct(float money){
System.out.println("拿到钱，开始危险的表演："+money);
} 
}

InvocationHandler的invoke方法有拦截的功能，执行代理对象的任何方法，都会经过该方法

public class Client {
public static void main(String[] args) {
//一个剧组找演员：
final Actor actor = new Actor();//直接
/**
    * 代理：
    *   间接。
    * 获取代理对象：
    *   要求：
    *     被代理类最少实现一个接口
    * 创建的方式
    *   Proxy.newProxyInstance(三个参数)
    * 参数含义：
    *   ClassLoader：和被代理对象使用相同的类加载器。
    *   Interfaces：和被代理对象具有相同的行为。实现相同的接口。
    *   InvocationHandler：如何代理。
    * 策略模式：使用场景是：
    *         数据有了，目的明确。
    *         如何达成目标，就是策略。
* 
*/
IActor proxyActor = (IActor) Proxy.newProxyInstance(
	actor.getClass().getClassLoader(), 
	actor.getClass().getInterfaces(), 
	new InvocationHandler() {
/**
* 执行被代理对象的任何方法，都会经过该方法。
* 此方法有拦截的功能。
* 
* 参数：
*    proxy：代理对象的引用。不一定每次都用得到
*    method：当前执行的方法对象
*    args：执行方法所需的参数
* 返回值：
*    当前执行方法的返回值
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) 
throws Throwable {
        String name = method.getName();
        Float money = (Float) args[0];
        Object rtValue = null;
            //每个经纪公司对不同演出收费不一样，此处开始判断
        if("basicAct".equals(name)){
        //基本演出，没有 2000 不演
        if(money > 2000){
        //看上去剧组是给了 8000，实际到演员手里只有 4000
        //这就是我们没有修改原来 basicAct 方法源码，对方法进行了增强
        rtValue = method.invoke(actor, money/2);
        } }
        if("dangerAct".equals(name)){
        //危险演出,没有 5000 不演
        if(money > 5000){
        //看上去剧组是给了 50000，实际到演员手里只有 25000
        //这就是我们没有修改原来 dangerAct 方法源码，对方法进行了增强
        rtValue = method.invoke(actor, money/2);
        } }
        return rtValue;
}
});
//没有经纪公司的时候，直接找演员。
// actor.basicAct(1000f);
// actor.dangerAct(5000f);
//剧组无法直接联系演员，而是由经纪公司找的演员
	proxyActor.basicAct(8000f);
	proxyActor.dangerAct(50000f);

	} 
}

基于子类的动态代理Enhancer.create

MethodInterceptor的intercept方法

接下来我们就讲讲怎么写cglib代理：

• 需要引入cglib – jar文件， 但是spring的核心包中已经包括了cglib功能，所以直接引入spring-core-3.2.5.jar即可。
• 引入功能包后，就可以在内存中动态构建子类
• 代理的类不能为final，否则报错【在内存中构建子类来做扩展，当然不能为final，有final就不能继承了】
• 目标对象的方法如果为final/static, 那么就不会被拦截，即不会执行目标对象额外的业务方法

还是那个演员的例子，只不过不让他实现接口。
/**
* 一个演员
*/
public class Actor{//没有实现任何接口
public void basicAct(float money){
System.out.println("拿到钱，开始基本的表演："+money);
}
public void dangerAct(float money){
System.out.println("拿到钱，开始危险的表演："+money);
    }
}

public class Client {
/**
* 基于子类的动态代理
* 要求：
* 被代理对象不能是最终类
* 用到的类：
* Enhancer
* 用到的方法：
* create(Class, Callback)
* 方法的参数：
* Class：被代理对象的字节码
* Callback：如何代理
* @param args
*/
public static void main(String[] args) {
final Actor actor = new Actor();
Actor cglibActor = (Actor) Enhancer.create(actor.getClass(),
new MethodInterceptor() {
/**
* 执行被代理对象的任何方法，都会经过该方法。在此方法内部就可以对被代理对象的任何
方法进行增强。
* 
* 参数：
* 前三个和基于接口的动态代理是一样的。
* MethodProxy：当前执行方法的代理对象。
* 返回值：
* 当前执行方法的返回值
*/
@Override
public Object intercept(Object proxy, Method method, Object[] args, 
MethodProxy methodProxy) throws Throwable {
            String name = method.getName();
            Float money = (Float) args[0];
            Object rtValue = null;
            if("basicAct".equals(name)){
            //基本演出
            if(money > 2000){
            rtValue = method.invoke(actor, money/2);
            } 
            }
                if("dangerAct".equals(name)){
            //危险演出
            if(money > 5000){
            rtValue = method.invoke(actor, money/2);
            } }
            return rtValue;
		}
	});
	cglibActor.basicAct(10000);
	cglibActor.dangerAct(100000);
	} 
}

cglib代理分解

//需要实现MethodInterceptor接口
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;
    }

}

使用cglib就是为了弥补动态代理的不足【动态代理的目标对象一定要实现接口】