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

工厂模式的发展

简单工厂模式

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

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

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

public class MacComputer extends Computer {@Overridepublic void setOperationSystem() {System.out.println("Mac笔记本");}
}
public class MiComputer extends Computer {@Overridepublic 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 {@Overridepublic Computer makeComputer() {//去new一个制作的实例return new MacComputer();}
}
public class MiComputerFactory implements ComputerFactory {@Overridepublic 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{@Overridepublic void submit(String proof) {System.out.println(String.format("老板欠薪跑路，证据如下：%s",proof));}@Overridepublic void defend() {System.out.println(String.format("铁证如山，%s还牛翠花血汗钱","马旭"));}}

再写一个律师类

public class DynProxyLawyer implements InvocationHandler {private Object target;//被代理的对象public DynProxyLawyer(Object obj){this.target=obj;}@Overridepublic 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();}
}