Java代理模式

Java代理模式 分为了三种 静态代理 动态代理 和 Cglib

静态代理

　　静态代理 和目标对象都需要实现目标相同的 某个接口或者父类

　　代码

    //定义一个接口

　　public interface UserInterface{

　　　　 void eat();

    }

//定义一个目标对象
public class User implments UserInterface{

         public  void eat(){

            System.out.println("eat apple")

     }  
}                                     

　　

//定义一个静态代理
public class StaticProxyUser implments UserInterface{

    priavte UserInterface user; 
   StaticProxyUser(User user){ 

    this.user=user; 
   } 

   public void eat(){
   user.eat(); 
  } 
} 

测试

public class Test{
    public static void main(String[] args){
            User user = new User();
            StaticProxyUser spu = new StaticProxyUser(user);
            spu.eat();
    }

}        

静态代理的优缺点

　　优点，不改变目标对象的情况下，添加功能

　　缺点，必须实现接口或者父类，导致太多

动态代理

　　相比叫于静态代理，动态代理不需要继承接口或者父类，而且代理对象是在内存中建立(jdk java.lang.reflect.Proxy.newProxyInstance(....)方法有参数，这里省略了)

　　代码

　

//在上边接口 和 目标对象的基础上
public class ProxyTest{

　　private Object user;
    
    ProxyTest(User user){

        this.user=user

}
    public class getProxy(){
      
      Proxy p = new Proxy;
    
      Object pp=p.newProxyInstance(user.getClass().getClassLoader(),
                   user.getClass().getInterfacer(),
                   new InvocationHandler(
                       public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
       　　　　　　　　　　　　　　Object returnValue = method.invoke(usr, args);
        　　　　　　　　　　　　　　　　retrun returnValue;
}
)

)
　　　　return pp;
}

}                                                        

//测试类 
public class Test() i{
    
      public static void main(String[] args){
             UserInterface user = new User
　　　　　　　　//此时就在内存中生成代理对象
             UserInterface u =(UserInterface)ProxyTest(user).getProxyInstance();
       　　　 u.save();
    }
}

Cjlib代理

　　目标对象可以不实现接口或者父类

　　使用目标对象子类的方式实现代理

　　底层是使用字节码处理框架ASM来转换字节码并且生成新的类

//目标对象没有实现接口或者父类

public class UserDao {

    public void eat() {
        System.out.println("eat apple");
    }
}

　　

//创建代理,需要使用拦截器
public class ProxyTest implements MethodInterceptor{
     private Object user;

    public ProxyFactory(Object user) {
        this.user = user;
    }

    //给目标对象创建一个代理对象
    public Object getProxyInstance(){
        //1.工具类
        Enhancer en = new Enhancer();
        en.setSuperclass(target.getClass());
        en.setCallback(this);
        //4.创建子类(代理对象)
        return en.create();

    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
       
        Object returnValue = method.invoke(user, args);

        return returnValue;
    }
}
     
}