小小理解动态代理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*/