小记：动态代理和工厂模式

工厂模式的发展

简单工厂模式

假如有小米和苹果两家电脑要生产，现有一个工厂接到活了
那么首先写一个接口

public abstract class Computer {
    public abstract void setOperationSystem();
}

再细化小米和苹果的制作方法

public class MacComputer extends Computer {
    @Override
    public void setOperationSystem() {
        System.out.println("Mac笔记本");
    }
}
public class MiComputer extends Computer {
    @Override
    public void setOperationSystem() {
        System.out.println("小米笔记本");
    }
}

建立工厂去执行这两个制作方法，当然接到单后，才做

public class SimpleComputerFactory {
    public static Computer makeComputer(String brand) {
        Computer computer=null;
        switch (brand) {
            case "mac":
                computer=new MacComputer();
                break;
            case "mi":
                computer=new MiComputer();
                break;
            default:
                break;
        }
        return computer;
    }
}

使用

public static void main(String[] args) {
        Computer computer= SimpleComputerFactory.makeComputer("mi");
        computer.setOperationSystem();
  }

输出

小米笔记本

这方法好是好 但是违背了开闭原则，如果要才接单比如华为的就要新写一个制作类 且要改工厂的方法
所以不好 ，应该去扩展而不是去修改

工厂模式

其实差不多 ，为了不去修改原来的方法，只能设计为每一个工厂只生成固定的产品
例如华为就生成华为

public interface ComputerFactory {
     Computer makeComputer();
}
public class MacComputerFactory implements ComputerFactory {
    @Override
    public Computer makeComputer() {
    //去new一个制作的实例
        return new MacComputer();
    }
}
public class MiComputerFactory implements ComputerFactory {
    @Override
    public Computer makeComputer() {
        return new MiComputer();
    }
}

具体使用

public static void main(String[] args) {
        //生产Mac电脑
        ComputerFactory macFactory=new MacComputerFactory();
        macFactory.makeComputer().setOperationSystem();

        //生产小米电脑
        ComputerFactory miFactory=new MiComputerFactory();
        miFactory.makeComputer().setOperationSystem();
    }

动态代理

原理
首先Jdk的动态代理实现方法是依赖于接口的，首先使用接口来定义好操作的规范。然后通过Proxy类产生的代理对象调用被代理对象的操作，而这个操作又被分发给InvocationHandler接口的 invoke方法具体执行

大白话就是用一个proxy类去调用被调用的方法

先讲一个静态代理

动态代理

先创建一个原告类

public class CuiHuaNiu implements ILawSuit{
    @Override
    public void submit(String proof) {
        System.out.println(String.format("老板欠薪跑路，证据如下：%s",proof));
    }
    @Override
    public void defend() {
        System.out.println(String.format("铁证如山，%s还牛翠花血汗钱","马旭"));
    }

}

再写一个律师类

public class DynProxyLawyer implements InvocationHandler {
    private Object target;//被代理的对象
    public DynProxyLawyer(Object obj){
        this.target=obj;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("案件进展："+method.getName());
        Object result=method.invoke(target,args);
        return result;
    }
}

这里的代理类需要去继承InvocationHandler接口 当使用的时候invoke方法会去调用被代理类的方法
再写一个工厂类

public class ProxyFactory {
    public static Object getDynProxy(Object target) {
        InvocationHandler handler = new DynProxyLawyer(target);
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), handler);
    }

}

这个工厂就是去返回一个动态的Proxy类，他需要一个代理类 那么就去创建他，也需要一下他的其他信息
loader是去定义这个新的代理类，interfaces获得这个类的接口去依赖

具体使用

public class Text {
    public static void main(String[] args) {
        ILawSuit proxy= (ILawSuit) ProxyFactory.getDynProxy(new CuiHuaNiu());
        proxy.submit("工资流水在此");
        proxy.defend();
    }
}

案件进展：submit
老板欠薪跑路，证据如下：工资流水在此
案件进展：defend
铁证如山，马旭还牛翠花血汗钱

动态代理