java代理

什么是代理

代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能.

这里使用到编程中的一个思想:不要随意去修改别人已经写好的代码或者方法,如果需改修改,可以通过代理的方式来扩展该方法

java中的代理模式：

        定义：给目标对象提供一个代理对象，并且由代理对象控制对目标对象的引用

        目的：1：通过代理对象的方式间接的访问目标对象，防止直接访问目标对象给系统带来不必 要的复杂性:2：通过代理业务对原有业务进行增强

 java创建代理对象：

静态代理，基于jdk(接口)的动态代理，基于CGLLIB（父类）的动态代理。

相关概念：

        目标类：原对象，我们需要代理对象控制他的访问，拓展其功能。

        代理类：代理模式产生的对象，是原对象“替身”,已经在原有基础上修改逻辑

静态代理

编写代理类：实现目标的接口或者直接继承目标类，完成逻辑的修改

接口实现方式：

关于接口的方式，我们在实现接口的时候，目标类和代理类都必须实现目标接口当中所实现的方法，从某种意义上代理类就可以帮我们实现目标类当中的方法，并且代理类还可以有自己的扩展方法。

举例子：

最开始我们想买东西就必须代购，因为只有代购员才知道真实的工厂在哪里

代码实现：

首先定义接口------相当于工厂地址和功能

public interface ByClothes {
    void clothes(String size);
}
定义目标对象---制造衣服的工厂
 
public class ClothesFactory implements ByClothes {
    @Override
    public void clothes(String size) {
        System.out.println("已经为您制作好了一整套size为"+size+"的衣服。。。。。。。。");
    }
}
制造代理对象-------代购
 
public class proxy implements ByClothes {
 
    
    //被包含的真是对象
    public ClothesFactory factory;
    
    public proxy(ClothesFactory factory) {
        // TODO Auto-generated constructor stub
        this.factory = factory;
    }
    
    @Override
    public void clothes(String size) {
        FrontService();
        factory.clothes(size);
        endService();
        
    }
    
    //前置服务
    public void FrontService() {
        System.out.println("根据您的需求进行市场调研");
    }
 
    //前置服务
    public void endService() {
        System.out.println("为您提供一条龙的包办服务");
    }
}

制造测试类------买衣服的人

public class Test {
    public static void main(String[] args) {
        ClothesFactory clothesFactory = new ClothesFactory();
        proxy proxy = new proxy(clothesFactory);
        proxy.clothes("XXl");
    }
}

真实静态代理

细节：我们的目标对象必须实现我们的接口，同时代理对象也必须实现这一接口

 

静态代理存在哪些问题？

违反了开闭原则：

程序对访问开放，对修改关闭，换句话来说，当需求发生变化时，我们可以增加新模块来解决新需求，而不是通过改变原来的代码来解决我们的新需求

动态代理：

举例子：

当发现这是一个商机的时候，聚拢身边的朋友成立公司

公司的优势：可以代购很多种商品，不是定性的代购

java实现：

1.新建接口

public interface ByShoot {
    void byShoot(String size);
}

2.新建工厂

public class ShootFactory implements ByShoot{
 
    @Override
    public void byShoot(String size) {
        System.out.println("已经为您生产出了尺码为"+size+"的鞋子");
    }
 
}

3.新建海外代购公司

public class LisiFactory implements InvocationHandler {
 
    // 被代理的对象
    private Object factory ;
 
    public Object getFactory() {
        return factory;
    }
 
    public void setFactory(Object factory) {
        this.factory = factory;
    }
 
    //ssm: Spring SpringMVC mybitys
    //Spring:AOP IOC +....
    //AOP:代理    (面向切面的编程)
    // 通过代理对象对方法进行增强
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        FrontService();
        Object retObject = method.invoke(factory, args);  //这里用了反射的思想，因为我们不知道调用的是那个工厂的那个方法
        endService();
        return null;
    }
 
    // 前置服务
    public void FrontService() {
        System.out.println("根据您的需求进行市场调研");
    }
 
    // 后置服务
    public void endService() {
        System.out.println("为您提供一条龙的包办服务");
    }
    
    //调度员工
    /**
    * 1 新建一名员工
     * 2.告诉员工工厂地址
     * this:绑定
     * @return
     */
    public Object getProxyInstance() {
        // TODO Auto-generated method stub
        return Proxy.newProxyInstance(factory.getClass().getClassLoader(), factory.getClass().getInterfaces(), this);
    }
    
    
}

4.新建测试类---买东西的人

public class Test {
    public static void main(String[] args) {
        ClothesFactory clothesFactory = new ClothesFactory();
        ShootFactory shootFactory = new ShootFactory();
        LisiFactory lisiFactory = new LisiFactory();
        lisiFactory.setFactory(shootFactory);
        ByShoot yuangong1 = (ByShoot) lisiFactory.getProxyInstance();
        yuangong1.byShoot("42");
        lisiFactory.setFactory(clothesFactory);
        ByClothes yuangong  = (ByClothes) lisiFactory.getProxyInstance();
        yuangong.clothes("XXL");
    }
}