Java之动态代理

所谓动态代理是指：在程序运行期间根据需要动态创建代理类及其实例来完成具体的功能。

使用JDK动态代理步骤：
1.创建被代理的接口和类；
2.创建InvocationHandler接口的实现类，在invoke方法中实现代理逻辑；
3.通过Proxy的静态方法newProxyInstance( ClassLoaderloader, Class[] interfaces, InvocationHandler h)创建一个代理对象
4.使用代理对象。

//创建被代理的接口和类
接口:
public interface IShopping {
//、下单函数：参数商品id、数量、价格，返回一个订单类的实例
 public Order OrderFun(String productId,int count,double price);
//支付函数：参数为订单，返回：支付的结果
 public boolean pay(Order order);
//确认收货：参数为订单，返回结构为boolean值。
 public boolean confirm(Order order);
 //评价：参数为订单和评价内容，返回结构为boolean值
 public boolean memo(Order order,String message);
 }
//Order订单类
public class Order {
private String productID;//订单编号
 private int count;//数量
 private double price;//价格
public String getProductID() {
  return productID;
  }
 public void setProductID(String productID) {
  this.productID = productID;
  }
   public int getCount() {
  return count;
  }
 public void setCount(int count) {
  this.count = count;
  }
   public double getPrice() {
  return price;
  }
  public void setPrice(double price) {
  this.price = price;
  }
  public Order(String productID, int count, double price) {
  super();
  this.productID = productID;
  this.count = count;
  this.price = price;
  }
public Order() {
  this.productID=generateProductID();
  }
  生成订单编号，其算法为：
 类的订单编号生成算法“年月日时分秒XXXX”，其中XXXX是四位随机数
public static String generateProductID(){
  String strProductID="";//临时变量 订单号
   String strRdm="";//随机数
  //日期时间的格式设置
  SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
  strProductID = sdf.format(new Date());
  //生成四位随机数
  //strRdm=String.valueOf(rdm.nextInt(10))+String.valueOf(rdm.nextInt(10))+String.valueOf(rdm.nextInt(10))+String.valueOf(rdm.nextInt(10));
  strRdm=String.valueOf(1000+rdm.nextInt(9000));//1000-9999的四位随机数
  return strProductID+strRdm;
  }
@Override
 public String toString() {
 StringBuffer sb = new StringBuffer();
  sb.append("productId=").append(this.getProductID()).append(",");
  sb.append("count="+this.getCount()+",");
  sb.append("price="+this.getCount()+"");
  return sb.toString();
  }





 两个接口的实现类:
public class JDShopping implements IShopping{
@Override
 public Order OrderFun(String productId, int count, double price) {
System.out.println("京东 上 下单 单号为:"+productId);
  return new Order(productId, count, price);
  }
@Override
 public boolean pay(Order order) {
 System.out.println("京东上开始支付,其订单为:"+order);
  return true;
  }
@Override
 public boolean confirm(Order order) {
 System.out.println("京东上确认收货");
  return true;
  }
@Override
 public boolean memo(Order order, String message) {
 System.out.println("京东上的评价:订单为:"+order.toString()+"评价内容:"+message);
  return true;
  }

 }

public class TBShopping implements IShopping{
@Override
 public Order OrderFun(String productId, int count, double price) {
 System.out.println("淘宝上 下单 单号为:"+productId);
  return new Order(productId, count, price);
  }
@Override
 public boolean pay(Order order) {
 System.out.println("淘宝上开始支付,其订单为:"+order);
  return true;
  }

@Override
 public boolean confirm(Order order) {
 System.out.println("淘宝上确认收货");
  return true;
  }
@Override
 public boolean memo(Order order, String message) {
 System.out.println("淘宝上的评价,订单为:"+order.toString()+"评价为:"+message);
  return true;
  }
}

利用工厂模式生产上述目标的实例-->简单工厂
public class ShoppingFactory {
//生成两个静态常量
  final public static String TAO_BAO_TYPE="taobaoType";//淘宝系
  final public static String JING_DONG_TYPE="jingdongType";//京东系
//获取目标实例的方法   返回接口类型
public static IShopping getInstance(String shoppingType){
if(shoppingType!=null&&shoppingType.equalsIgnoreCase(TAO_BAO_TYPE)){
    return new TBShopping();
}else if(shoppingType!=null&&shoppingType.equalsIgnoreCase(JING_DONG_TYPE)){
    return new JDShopping();
}
    return null;
    }
    }
 

创建InvocationHandler接口的实现类，在invoke方法中实现代理逻辑；
通过Proxy的静态方法newProxyInstance( ClassLoaderloader, Class[] interfaces, InvocationHandler h)创建一个代理对象


//InvocationHandler接口的实现类
public class JDKProxy implements InvocationHandler{
//被代理对象 object类型
  private Object targetObject;
  
  //创建一个代理对象   这里的obj指的是被代理对象
  public Object CreateProxy(Object obj) {
  this.targetObject = obj;
  return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(), targetObject.getClass().getInterfaces(), this);
  //第一个参数是指定被代理对象的类加载器（我们传入当前被代理对象的类加载器）
  //第二个参数是被代理对象的类需要实现的接口（我们传入被代理对象的类实现的接口，这样生成的被代理对象的类类和代理类就实现了相同的接口）
//第三个参数是invocation handler，用来处理方法的调用。这里传入this
  }
  
@Override
 public Object invoke(Object proxy, Method method, Object[] args)
  throws Throwable {
  //前置区域
  System.out.println("前置条件及相关工作");
  //工作区 执行具体任务
  Object obj = method.invoke(targetObject, args);
  //后置区域
  System.out.println("后置条件为相关工作");
  return obj;
  }

//使用代理对象

public class TestShopping {
IShopping shopping = ShoppingFactory.getInstance(ShoppingFactory.TAO_BAO_TYPE);//工厂类 传淘宝的类型

 调用区
 //创建实现InvocationHandler接口的类的实例
  JDKProxy proxy = new JDKProxy();
  IShopping proxysh = (IShopping) proxy.CreateProxy(shopping);//创建代理对象
//执行区
String product = Order.generateProductID();
  proxysh.OrderFun(product, 5, 5.0);