1、代理模式的原理
使得代理类更加具有灵活性
- 静态代理
public class test {
@Test
public void test1(){
NikeClothFactory nike = new NikeClothFactory();
ProxyClothFactory proxyClothFactory = new ProxyClothFactory(nike);
proxyClothFactory.produceCloth();
}
}
interface ClothFactory{
void produceCloth();
}
//代理类
class ProxyClothFactory implements ClothFactory{
private ClothFactory factory;//用被代理类对象进行实例化
public ProxyClothFactory(ClothFactory factory){
this.factory=factory;
}
@Override
public void produceCloth() {
System.out.println("代理工厂做一些准备工作");
factory.produceCloth();
System.out.println("代理工厂做一些后续工作");
}
}
class NikeClothFactory implements ClothFactory{
@Override
public void produceCloth() {
System.out.println("Nike工厂生产一批运动服");
}
}
/*
代理工厂做一些准备工作
Nike工厂生产一批运动服
代理工厂做一些后续工作
*/
- 动态代理
public class test {
public static void main(String[] args) {
SuperMan superMan = new SuperMan();
Human o = (Human) ProxyFactory.getRoxyInstance(superMan);
System.out.println(o.getBelief());
o.eat("大米饭");
}
}
interface Human{
String getBelief();
void eat(String food);
}
class ProxyFactory{
//解决如何根据加载到内存中的被代理类,动态创建一个代理类及其对象
public static Object getRoxyInstance(Object obj){//obj:被代理类对象
myInvocationHandler h=new myInvocationHandler();
h.bind(obj);
return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(),h);
}
}
class myInvocationHandler implements InvocationHandler{
private Object obj;//赋值时需要使用被代理类的对象进行赋值
public void bind(Object obj){
this.obj=obj;
}
//当通过代理类的对象调用方法a时,就会自动的调用如下的方法:invoke()
//将被代理类要执行的功能声明在此方法中
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//为代理类对象调用的方法,此方法也就作为了被代理类要调用的方法
Object returnValue=method.invoke(obj,args);
return returnValue;
}
}
//被代理类
class SuperMan implements Human{
@Override
public String getBelief() {
return "I believe i can fly";
}
@Override
public void eat(String food) {
System.out.println("喜欢吃"+food);
}
}
2、AOP
class myInvocationHandler implements InvocationHandler{
private Object obj;//赋值时需要使用被代理类的对象进行赋值
public void bind(Object obj){
this.obj=obj;
}
//当通过代理类的对象调用方法a时,就会自动的调用如下的方法:invoke()
//将被代理类要执行的功能声明在此方法中
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
HumanUtil humanUtil = new HumanUtil();
humanUtil.fun1();
//为代理类对象调用的方法,此方法也就作为了被代理类要调用的方法
Object returnValue=method.invoke(obj,args);
humanUtil.fun2();
return returnValue;
}
}
class HumanUtil{
public void fun1(){
System.out.println("========方法一=========");
}
public void fun2(){
System.out.println("========方法二=========");
}
}