动态代理

2024-03-06 17:36:38

 

2.为什么要找中介

为什么要找中介?
1.中介是专业的,方便.
2.家长现在不能自己去找学校。家长没有能力访问学校.或者美国学校不接收个人来访

买东西都是商家卖, 商家是某个商品的代理, 你个人买东西,肯定不会让你接触到厂家的.

第二章:静态代理

动态代理

2.1 使用代理模式的作用

  1. 功能增强:在你原有的功能上,增加了额外的功能.新增加的功能,叫做功能增强
  2. 控制访问:代理类不让你访问目标,例如商家不让用户访问厂家

2.2 实现代理的方式

1.静态代理:

1)代理类是自己手工实现的,自己创建一个java类,表示代理类

2)同时你所要代理的目标

特点：1）实现简单2）容易理解。
模拟一个用户购买u盘的行为。
用户是客户端类
商家：代理，代理某个品牌的u盘。
厂家：目标类。
三者的关系：用户（客户端）-—-商家（代理）-—-厂家（目标）
商家和厂家都是卖u盘的，他们完成的功能是一致的，都是卖u盘。

实现步骤
1.创建一个接口,定义卖u盘的方法,表示你的厂家和商家做的事情
2.创建厂家类,实现1步骤的接口
3.创建商家,就是代理,也需要实现1步骤中的接口
4.创建客户端类,调用商家的方法买一个u盘

2.3 具体实现

动态代理

实现步骤
1.创建一个接口,定义卖u盘的方法,表示你的厂家和商家做的事情

package com.rango.service;
//表示功能的，厂家和商家都要完成的功能
public interface usbSell {
    /**
     * 定义一个方法 参数 amount:表示一次购买的数量,暂时不用
* 返回值表示一个u盘的价格
* @param amount
* @return
*/
float sell(int amount);
}

2.创建厂家类,实现1步骤的接口

package com.rango.factory;

import com.rango.service.usbSell;
//目标类:金士顿厂家,不接受用户的单独购买
public class UsbKingFactory implements usbSell {
    /**
     * 定义一个方法 参数 amount:表示一次购买的数量,暂时不用
* 返回值表示一个u盘的价格
*
     * @param amount
* @return
*/
@Override
    //一个128G的U盘是85元.
    //后期根据amount,可以实现不同的价格,例如10000个,单击是80,50000个75
    public float sell(int amount) {
        return 85.0f*amount;
    }
}

3.创建商家,就是代理,也需要实现1步骤中的接口

package com.rango.business;

        import com.rango.factory.UsbKingFactory;
        import com.rango.service.usbSell;


//淘宝是一个商家,代理金士顿U盘的销售
public class TaoBao implements usbSell {
    //      声明 商家代理的厂家具体是谁
    private UsbKingFactory factory =new UsbKingFactory();

    @Override
//    实现销售U盘功能
    public float sell(int amount) {
//        向厂家发送订单,告诉厂家,我买了U盘,厂家发货
//        发送给工厂,我需要的订单,返回报价
        float price = factory.sell(amount);
//        商家需要加价也就是代理要增加价格
        price = price + 25;
        //在目标类的方法调用后,你做的其他功能,都是增强的意思
        System.out.println("淘宝再给你返回一个优惠券,或者红包");
//        增加的价格
        return price;
    }
}

4.创建客户端类,调用商家的方法买一个u盘

import com.rango.business.TaoBao;

public class shopMain {
    public static void main(String[] args){
//             创建代理的商家淘宝对象
        TaoBao taoBao = new TaoBao();
//        我只向淘宝买一件产品,得到报价
        float price = taoBao.sell(2);
        System.out.println("购买一件产品.淘宝的报价为: "+price);
    }
}

动态代理

package Test; import com.rango.Impl.HelloServiceImpl; import com.rango.service.HelloService; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; public class TestApp { public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { // HelloService service = new HelloServiceImpl(); // service.sayhello("张三"); // 以上是常规方法执行sayhello // 下面我们使用反射机制进行创建sayhello方法,核心Method(类中的方法) HelloServiceImpl target = new HelloServiceImpl(); // 获取sayhello名称对应的Method类对象 // public Method getM ethod(String name, Class<?>... parameterTypes) // 加入,该方法的参数有多个该怎么办? // parameterTypes参数是一个类对象数组，按声明的顺序标识方法的形式参数类型。 Method method = HelloService.class.getMethod("sayhello", String.class); // 通过Metho可以执行sayhello方法的调用 /* * public Object invoke(Object obj, Object... args) * 表示执行方法的调用 * 参数: * 1.Object,表示对象,要执行这个对象的方法 * 2.Object...args,方法执行时的参数值 * 返回值: * Object:方法执行后的返回值 * */ Object ret = method.invoke(target, "李四"); } }

   

"sayhello", String.class,Integer.class);

   

public Method getMethod(String name, Class<?>... parameterTypes)

       

public Object invoke(Object obj, Object... args) * 表示执行方法的调用 * 参数: * 1.Object,表示对象,要执行这个对象的方法 * 2.Object...args,方法执行时的参数值 * 返回值: * Object:方法执行后的返回值 *

       

package com.rango.service; public interface usbSell { /** * 定义一个方法 参数 amount:表示一次购买的数量,暂时不用 * 返回值表示一个u盘的价格 * @param amount * @return */ float sell(int amount); }

   

package com.rango.factory; import com.rango.service.usbSell; //目标类:金士顿厂家,不接受用户的单独购买 public class UsbKingFactory implements usbSell { /** * 定义一个方法 参数 amount:表示一次购买的数量,暂时不用 * 返回值表示一个u盘的价格 * * @param amount * @return */ @Override //一个128G的U盘是85元. // 后期根据amount,可以实现不同的价格,例如10000个,单击是80,50000个75 public float sell(int amount) { return 85.0f*amount; } }

   

package com.rango.business; import com.rango.factory.UsbKingFactory; import com.rango.service.usbSell; //淘宝是一个商家,代理金士顿U盘的销售 public class TaoBao implements usbSell { // 声明 商家代理的厂家具体是谁 private UsbKingFactory factory =new UsbKingFactory(); @Override // 实现销售U盘功能 public float sell(int amount) { // 向厂家发送订单,告诉厂家,我买了U盘,厂家发货 // 发送给工厂,我需要的订单,返回报价 float price = factory.sell(amount); // 商家需要加价也就是代理要增加价格 price = price + 25; //在目标类的方法调用后,你做的其他功能,都是增强的意思 System.out.println("淘宝再给你返回一个优惠券,或者红包"); // 增加的价格 return price; } }

   

import com.rango.business.TaoBao; public class shopMain { public static void main(String[] args){ // 创建代理的商家淘宝对象 TaoBao taoBao = new TaoBao(); // 我只向淘宝买一件产品,得到报价 float price = taoBao.sell(2); System.out.println("购买一件产品.淘宝的报价为: "+price); } }

   

所以我们再次总结代理类完成的功能:

  1. 目标类中方法的调用
  2. 功能增强

动态代理
2)知道动态代理能做什么?

package Test; import com.rango.Impl.HelloServiceImpl; import com.rango.service.HelloService; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; public class TestApp { public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { // HelloService service = new HelloServiceImpl(); // service.sayhello("张三"); // 以上是常规方法执行sayhello // 下面我们使用反射机制进行创建sayhello方法,核心Method(类中的方法) HelloServiceImpl target = new HelloServiceImpl(); // 获取sayhello名称对应的Method类对象 // public Method getM ethod(String name, Class<?>... parameterTypes) // 加入,该方法的参数有多个该怎么办? // parameterTypes参数是一个类对象数组，按声明的顺序标识方法的形式参数类型。 Method method = HelloService.class.getMethod("sayhello", String.class); // 通过Metho可以执行sayhello方法的调用 /* * public Object invoke(Object obj, Object... args) * 表示执行方法的调用 * 参数: * 1.Object,表示对象,要执行这个对象的方法 * 2.Object...args,方法执行时的参数值 * 返回值: * Object:方法执行后的返回值 * */ Object ret = method.invoke(target, "李四"); } }

   

"sayhello", String.class,Integer.class);

   

public Method getMethod(String name, Class<?>... parameterTypes)

       

public Object invoke(Object obj, Object... args) * 表示执行方法的调用 * 参数: * 1.Object,表示对象,要执行这个对象的方法 * 2.Object...args,方法执行时的参数值 * 返回值: * Object:方法执行后的返回值 *

       

 

 

 

  
 
Object invoke(Object proxy,方法 method,Object[] args)throws Throwable处理代理实例上的方法调用并返回结果。        

 

// 向厂家发送订单,告诉厂家,我买了U盘,厂家发货 // 发送给工厂,我需要的订单,返回报价 float price = factory.sell(amount);

   

public static Object newProxyInstance( ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) throws IllegalArgumentException

       

public interface UsbSell { float sell(int amount); }

   

第二步:创建目标类实现接口

 
public class UsbKingFactory implements UsbSell { @Override public float sell(int amount) { System.out.println("目标类中,执行了sell目标方法"); return 85.02f; } }    

public class MyHandle implements InvocationHandler { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { return null; } }

   

//之前的代理类 public class TaoBao implements usbSell { // 声明 商家代理的厂家具体是谁 private UsbKingFactory factory =new UsbKingFactory(); @Override // 实现销售U盘功能 public float sell(int amount) { // 向厂家发送订单,告诉厂家,我买了U盘,厂家发货 // 发送给工厂,我需要的订单,返回报价 float price = factory.sell(amount); // 商家需要加价也就是代理要增加价格 price = price + 25; //在目标类的方法调用后,你做的其他功能,都是增强的意思 System.out.println("淘宝再给你返回一个优惠券,或者红包"); // 增加的价格 return price; } }

   

//传入是谁的对象,就给谁创建代理 public MyHandle(Object target) { this.target = target; } invoke里面的设置 Object res =null; // 向厂家发送订单,告诉厂家,我买了U盘,厂家发货 // 发送给工厂,我需要的订单,返回报价 // float price = factory.sell(amount); res = method.invoke(target,args); //待执行目标方法,执行后返回值

   

public class MainShop { public static void main(String[] args){ // 1.创建对象,使用Proxy // 2.创建目标对象 UsbSell factory = new UsbKingFactory(); // 3.创建Invocationhandler对象 InvocationHandler myHandle = new MyHandle(factory); // 4.创建代理对象 UsbSell proxy = (UsbSell) Proxy.newProxyInstance(factory.getClass().getClassLoader(), factory.getClass().getInterfaces(), myHandle); // 通过代理执行方法 float price = proxy.sell(1); System.out.println("通过动态代理对象,调用方法:" +price); } }

   

执行成功.和之前动态代理模式一样

//比如,同事开发一个GoNong类 GoNong.class , GoNong gn=new GoNong() //我们需要增加一个print方法

   

public interface HelloService { /** * 打印报表,报表 * @param name * @return */ int print (String name); }

   
  1. 我们再加个接口实现类
 
public class GoNeng implements HelloService { @Override public int print(String name) { System.out.println("其他人写好的这个方法!"); return 2; } }        
  1. 我们如果相对上述功能进行修改,我们不可能直接去在原方法上进行修改

public class MyApp { public static void main(String[] args){ GoNeng gn = new GoNeng(); int i = gn.print("nihao1"); System.out.println("num" +i); } }

   

问题是如果我们想修改这个功能改怎么办?在不修改源代码的基础上,我们可以创建一个代理类,来增强这个类方法,

  1. 设置一个代理类实现功能的增强和代理
 
public class MyInvocationHandler implements InvocationHandler { private Object target=null; public MyInvocationHandler(Object target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // 调用目标方法,执行print()得到2 Object res = method.invoke(target,args); //返回为2的结果 //我们可以把结果再乘以2 if (res!=null) { Integer num = (Integer) res; res = num*2; } return null; } }    
  1. 我们仍回到主方法里面进行测试
 
public class MyApp { public static void main(String[] args){ // GoNeng gn = new GoNeng(); // int i = gn.print("nihao1"); // System.out.println("num" +i); GoNeng goNeng = new GoNeng(); InvocationHandler handler = new MyInvocationHandler(goNeng); HelloService proxy = (HelloService) Proxy.newProxyInstance(goNeng.getClass().getClassLoader(), goNeng.getClass().getInterfaces(), handler); int num = proxy.print("市场"); System.out.println("我们期望得到的 num =="+num); } }    

 

 

完结

动态代理,必须要有接口出现,如果没有,我们可以使用cglib实现

 

上一篇：Java线程死锁


下一篇：使用python从ustream api解码json