代理模式属于结构型模式(用于处理类或对象的组合),而代理模式又分为静态代理模式和动态代理模式。
1.静态代理模式
有些类由于自己功能有限,需要其他的类做一些工作来辅助完成某些功能,虽然这些辅助工作是必须的,但是委托类却不需要自己去做,一是他没有资源,二是它应该注重自己擅长的事情。这样一些代理类应运而生,它专门做一些事前和善后的处理,让委托类专注于自己的事情。
例如:
package com.huaxin.reflect.proxy;
/**
* 代理类
* @author minGe_000
*
*/
public class ProxyTeacher implements Subject{
private Subject sub;
public ProxyTeacher(Subject sub){
this.sub = sub;
}
public void before(){}
public void teach(){
before();
sub.teach();
after();
}
public void after(){}
}
package com.huaxin.reflect.proxy;
/**
* 主题类
* @author minGe_000
*
*/
public interface Subject {
public void teach();
}
package com.huaxin.reflect.proxy;
/**
* 主题实现类
* @author minGe_000
*
*/
public class Teacher implements Subject{
private String name;
public Teacher(String name){
this.name = name;
}
public void teach() {
System.out.println(name+"正在上Java课");
}
}
package com.huaxin.reflect.proxy;
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
Teacher tea = new Teacher("张三");
ProxyTeacher pt = new ProxyTeacher(tea);
pt.teach();
}
}
2.动态代理模式
1)一般的代理模式已经很好的解决了代码重复的问题,但是人总是不满足的,要是代理可以让程序帮我们生成该多好。
2)在JDK1.3以后,Java提供了动态代理技术,允许开发者在运行期创建接口的代理实例。
3)动态代理主要涉及到java.lang.reflect包中的两个类:Proxy和InvocationHandler。
4)其中InvocationHandler是一个接口,可以通过实现该接口定义代理逻辑,并通过反射机制调用目标类的代码,动态的
将代理逻辑和业务逻辑组合在一起。而Proxy利用InvocationHandler动态创建一个符合某一接口的实例,生成目标类的代理对象。
例如:
package com.huaxin.reflect.dynproxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
* 动态代理关联主题
* @author minGe_000
*
*/
public class DynProxyObj implements InvocationHandler{
private Object obj;
public DynProxyObj(Object obj){
this.obj = obj;
}
public void before(){
System.out.println("代理之前要执行的事情....");
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
before();
Object object = method.invoke(obj, args);
return object;
}
}
package com.huaxin.reflect.dynproxy;
public class Student implements Study{
@Override
public void study() {
System.out.println("学生学习");
}
}
package com.huaxin.reflect.dynproxy;
public interface Study {
public void study();
}
package com.huaxin.reflect.dynproxy;
/**
* 主题类
* @author minGe_000
*
*/
public interface Subject {
public void teach();
}
package com.huaxin.reflect.dynproxy;
/**
* 主题实现类
* @author minGe_000
*
*/
public class Teacher implements Subject{
private String name;
public Teacher(String name){
this.name = name;
}
public void teach() {
System.out.println(name+"正在上Java课");
}
}
package com.huaxin.reflect.dynproxy;
import java.lang.reflect.Proxy;
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
Teacher tea = new Teacher("小左");
DynProxyObj dpo = new DynProxyObj(tea);
//动态代理实现
Subject dyn = (Subject)Proxy.newProxyInstance(tea.getClass().getClassLoader(),tea.getClass().getInterfaces() , dpo);
dyn.teach();
Student stu = new Student();
DynProxyObj dynProxy = new DynProxyObj(stu);
Study s = (Study)Proxy.newProxyInstance(stu.getClass().getClassLoader(),stu.getClass().getInterfaces() , dynProxy);
s.study();
}
}