小小理解动态代理java

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

public class DynamicProxyForInterfaces {

    public static void main(String[] args) {
        //创建具体的委托类
        Mp3 mp3 = new Mp3();
        Mobile mobile = new Mobile();
        Mp3 sonyMp3 = new SonyMp3();
        Mobile iphone = new Iphone();
        //1.使用音乐播放处理器获取mp3的服务
        /*
         * 参数说明：
         * 第一个参数是类加载器，一般使用你需要的服务的那个接口的加载器即可
         * 第二参数是你想获取的服务的列表，即接口列表，比如mp3的服务列表就是Music音乐这一个
         * 第三个参数就是调用处理器，构造一个具体委托类的调用处理器
         * 这里的显式转换，说明了这个生成的动态代理实现了第二个参数的接口，即它可以提供这些接口的服务
         */
        Music music = (Music)Proxy.newProxyInstance(Music.class.getClassLoader(), mp3.getClass().getInterfaces(), 
                new MusicInvocationHandler(mp3));
        //会调用委托类mp3内的方法
        music.listenMusic();
        
        System.out.println("--------------------------");
        
        //这是一个只想播放电影的傲娇手机，放弃了音乐播放功能
        Movie movie = (Movie)Proxy.newProxyInstance(Movie.class.getClassLoader(), new Class[]{Movie.class}, 
                new MovieInvocationHandler(mobile));
        movie.seeMovie();
        
        System.out.println("--------------------------");
        //下面这样就会报错：ClassCastException，第二个参数中并没有Music服务，所以不能提供
        /*music = (Music)Proxy.newProxyInstance(Movie.class.getClassLoader(), new Class[]{Movie.class}, 
                new MovieInvocationHandler(mobile));
        music.listenMusic();*/
        
        /*第二个参数里加了音乐服务，这个手机就可以播放音乐了，但是调用处理器使用的是电影调用处理器，会打印出
            before see a movie...
            ...now begin music with mobile
            after see a movie...
        *所以此时调用处理器也需要更改
        */
        /*music = (Music)Proxy.newProxyInstance(Movie.class.getClassLoader(), new Class[]{Movie.class,Music.class}, 
                new MovieInvocationHandler(mobile));
        music.listenMusic();
        System.out.println("--------------------------");*/
        
        //使用索尼mp3播放音乐
        music = (Music)Proxy.newProxyInstance(Mp3.class.getClassLoader(), Mp3.class.getInterfaces(), 
                new Mp3InvocationHandler(sonyMp3));
        music.listenMusic();
        System.out.println("--------------------------");
        
        //使用iphone播放音乐
        music = (Music)Proxy.newProxyInstance(mobile.getClass().getClassLoader(), Mobile.class.getInterfaces(), 
                new MobileInvocationHandler(iphone));
        music.listenMusic();
        System.out.println("--------------------------");
        
        //使用iphone看电影
        movie = (Movie)Proxy.newProxyInstance(Mobile.class.getClassLoader(), Mobile.class.getInterfaces(),
                new MobileInvocationHandler(iphone));
        movie.seeMovie();
    }

}

/*
 * 动态代理是一个实现了一个或多个接口的具体委托类，
 * 通过代理类将方法请求发送到中介调用处理器，中介再根据具体委托类的类型进行具体方法的调用
 */




/*具体委托类和代理类要实现的模板接口--begin*/
//·听音乐的功能接口
interface Music{
    void listenMusic();
}
//·看电影的功能接口
interface Movie{
    void seeMovie();
}
/*具体委托类和代理类要实现的模板接口--end*/





/*具体的委托类：即真正提供“服务”的类--begin*/

//·可以播放音乐的mp3类
class Mp3 implements Music{

    @Override
    public void listenMusic() {
        System.out.println("...now begin music with mp3");
    }
}

//·既可以听音乐也可以看视频的手机类
class Mobile implements Music,Movie{

    @Override
    public void seeMovie() {
        System.out.println("...now begin movie with mobile");
    }

    @Override
    public void listenMusic() {
        System.out.println("...now begin music with mobile");
    }
    
}
/*具体的委托类：即真正提供“服务”的类--end*/




/*更具体的委托类，比如mp3下有索尼Sony的牌子，手机有iphone牌子--begin*/
class SonyMp3 extends Mp3{
    @Override
    public void listenMusic() {
        System.out.println("...now begin music with SonyMp3");
    }
}

class Iphone extends Mobile{
    @Override
    public void seeMovie() {
        System.out.println("...now begin movie(装逼) with Iphone");
    }

    @Override
    public void listenMusic() {
        System.out.println("...now begin music(装逼) with Iphone");
    }
}
/*更具体的委托类，比如mp3下有索尼Snoy的牌子，手机有iphone牌子--begin*/





/*调用处理器：将对代理的方法调用分发到真正的委托类，让对应的委托类提供服务--begin*/

// @可以进行音乐播放服务分发的调用处理器
class MusicInvocationHandler implements InvocationHandler{
    //委托类的实例对象
    private Music music;
    public MusicInvocationHandler(Music music){
        this.music = music;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        /*参数的含义：
         *proxy：代理类对象
         *method：要执行的方法
         *args：方法的参数
        */
        //音乐播放前可以做一些你想做的事
        System.out.println("before listen music...");
        //播放音乐
        method.invoke(music, args);
        //音乐播放后也可以做一些事情
        System.out.println("after listen music...");
        return null;
    }
    
}

//@ 可以进行视频播放服务分发的调用处理器
class MovieInvocationHandler implements InvocationHandler{
    //委托类的实例对象
    private Movie movie;
    public MovieInvocationHandler(Movie movie){
        this.movie = movie;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        /*参数的含义：
         *proxy：代理类对象
         *method：要执行的方法
         *args：方法的参数
        */
        //视频播放前可以做一些你想做的事
        System.out.println("before see a movie...");
        //播放视频
        method.invoke(movie, args);
        //视频播放后也可以做一些事情
        System.out.println("after see a movie...");
        return null;
    }
    
}

//当然也可以不面向具体的服务来写调用处理器，比如你就想面向mp3或者手机来写调用处理器，这只是继承树的层次问题，看具体需求了
//@ 面向mp3的调用处理器
class Mp3InvocationHandler implements InvocationHandler{
    //委托类的实例对象
    private Mp3 mp3;
    public Mp3InvocationHandler(Mp3 mp3){
        this.mp3 = mp3;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        /*参数的含义：
         *proxy：代理类对象
         *method：要执行的方法
         *args：方法的参数
        */
        //使用mp3前可以做一些你想做的事
        System.out.println("before use mp3...");
        //播放音乐
        method.invoke(mp3, args);
        //使用mp3后可以做一些你想做的事
        System.out.println("after use mp3...");
        return null;
    }
    
}

//@ 面向mobile的调用处理器
class MobileInvocationHandler implements InvocationHandler{
    //委托类的实例对象
    private Mobile mobile;
    public MobileInvocationHandler(Mobile mobile){
        this.mobile = mobile;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        /*参数的含义：
         *proxy：代理类对象
         *method：要执行的方法
         *args：方法的参数
        */
        //使用手机前可以做一些你想做的事
        System.out.println("before use mobile...");
        //播放视频
        method.invoke(mobile, args);
        //使用手机后也可以做一些事情
        System.out.println("after use mobile...");
        return null;
    }
    
}

/*调用处理器：将对代理的方法调用分发到真正的委托类，让对应的委托类提供服务--end*/