/**
 * @author itnanls(微信)
 * 我们的服务： 一路陪跑，顺利就业
 */
public interface HuaweiPhone {
    /**
     * 打电话的方法
     */
    void call();
}

/**
 * @author itnanls(微信)
 * 我们的服务： 一路陪跑，顺利就业
 */
public class Mate50 implements HuaweiPhone {
    public void call() {
        System.out.println("use a mate50 to make a call.");
    }
}

/**
 * @author itnanls(微信)
 * 我们的服务： 一路陪跑，顺利就业
 */
public class P50 implements HuaweiPhone {
    public void call() {
        System.out.println("use a p50 to make a call.");
    }
}

/**
 * @author itnanls(微信)
 * 我们的服务： 一路陪跑，顺利就业
 */
public class PhoneFactory {
    public static HuaweiPhone getCar(String type){
        if("p50".equalsIgnoreCase(type)){
            //其中可能有很复杂的操作
            return new P50();
        }else if("mate50".equalsIgnoreCase(type)){
            //其中可能有很复杂的操作
            return new Mate50();
        }else {
            throw new RuntimeException("There are no cell phones of this brand！");
        }
    }
}

/**
 * @author itnanls(微信)
 * 我们的服务： 一路陪跑，顺利就业
 */
public class Client {
    public static void main(String[] args) {
        HuaweiPhone p50 = PhoneFactory.getCar("p50");
        p50.call();
        HuaweiPhone mate50 = PhoneFactory.getCar("mate50");
        mate50.call();
    }
}

/**
 * @author itnanls(微信)
 * 我们的服务： 一路陪跑，顺利就业
 */
public interface Factory {
    /**
     * 统一的创建方法
     * @return
     */
    HuaweiPhone create();
}

/**
 * @author itnanls(微信)
 * 我们的服务： 一路陪跑，顺利就业
 */
public class Mate50Factory implements Factory {
    public HuaweiPhone create() {
        //中间省略一万行代码
        return new Mate50();
    }
}

/**
 * @author itnanls(微信)
 * 我们的服务： 一路陪跑，顺利就业
 */
public class P50Factory implements Factory {
    public HuaweiPhone create() {
        //中间省略一万行代码
        return new P50();
    }
}

public class Client {
    public static void main(String[] args) {
        Factory benzFactory = new BenzFactory();
        Car benz = benzFactory.create();
        benz.run();
        Factory bmwFactory = new BmwFactory();
        Car bmw = bmwFactory.create();
        bmw.run();
    }
}

/**
 * @author itnanls(微信)
 * 我们的服务： 一路陪跑，顺利就业
 */
public abstract class AbstractComputerProduct {

    // 生产电脑产品的共享方法
    public void sharedMethod(){
        System.out.println("这是生产电脑的产品线。");
    }

    abstract void networking();
}

/**
 * @author itnanls(微信)
 * 我们的服务： 一路陪跑，顺利就业
 */
public abstract class AbstractPhoneProduct {

    // 添加loge标签
    public void labelling(){
        System.out.println("这是小米的产品。");
    }

    abstract void networking();
}

public class MateBook16 extends AbstractComputerProduct {
    @Override
    public void networking() {
        System.out.println("Use a mateBook16 to connect to the Internet");
    }
}

public class Mate60 extends AbstractPhoneProduct {
    @Override
    public void networking() {
        System.out.println("Use a Mate60 to connect to the Internet");
    }
}

public class Mi12 extends AbstractPhoneProduct {
    @Override
    public void networking() {
        System.out.println("Use a Mi12 to connect to the Internet");
    }
}

public class MiBookPro15 extends AbstractComputerProduct {
    @Override
    public void networking() {
        System.out.println("Use a MiBookPro15 to connect to the Internet");
    }
}

public abstract class AbstractFactory {
    /**
     * 生产手机的方法
     * @return
     */
    abstract AbstractPhoneProduct createPhone();

    /**
     * 生产电脑的方法
     * @return
     */
    abstract AbstractComputerProduct createComputer();
}

public class MiFactory extends AbstractFactory {

    @Override
    AbstractPhoneProduct createPhone() {
        return new Mi12();
    }

    @Override
    AbstractComputerProduct createComputer() {
        return new MiBookPro15();
    }
}

public class HuaweiFactory extends AbstractFactory {

    @Override
    AbstractPhoneProduct createPhone() {
        return new Mate60();
    }

    @Override
    AbstractComputerProduct createComputer() {
        return new MateBook16();
    }
}

public class Client {
    public static void main(String[] args) {
        AbstractFactory factory = new MiFactory();
        AbstractPhoneProduct phone = factory.createPhone();
        phone.networking();
    }
}

public class Computer {
    // 鼠标
    public String mouse;
    // 键盘
    public String keyboard;
    // cpu
    public String cpu;
    // 内存
    public String memoryBank;
    // 主板
    public String mainBoard;

    ...省略getter和setter
}

public static class Builder{

    private final Computer computer = new Computer();

    public Builder buildMouse(String type){
        computer.setMouse("安装了一个"+ type +"鼠标");
        return this;
    }

    public Builder buildKeyboard(String type){
        computer.setKeyboard("安装了一个"+ type +"键盘");
        return this;
    }

    public Builder buildCpu(String type){
        computer.setCpu("安装了一个"+ type +"Cpu");
        return this;
    }


    public Builder buildMemoryBank(String type){
        computer.setMemoryBank("安装了一个"+ type +"MemoryBank");
        return this;
    }

    public Builder buildMainBoard(String type){
        computer.setMainBoard("安装了一个"+ type +"mainBoard");
        return this;
    }

    public Computer build(){
        return computer;
    }
}

public static void main(String[] args) {
    Computer computer = new Builder()
        .buildMainBoard("华硕")
        .buildCpu("英特尔")
        .buildMemoryBank("三星")
        .buildKeyboard("雷柏")
        .buildMouse("罗技")
        .build();
    System.out.println(computer);
}

public interface Singer {
    /**
     * 歌星都能唱歌
     */
    void sing();
}

public class MaleSinger implements Singer{

    private String name;

    public MaleSinger(String name) {
        this.name = name;
    }

    @Override
    public void sing() {
        System.out.println(this.name + "开始唱歌了！");
    }
}

/**
 * @author IT楠老师
 * @date 2020/5/28
 */
public class Agent implements Singer {

    private Singer singer;

    public Agent(Singer singer) {
        this.singer = singer;
    }

    @Override
    public void sing() {
        System.out.println("节目组找过来！需要演出，谈好演出费用。。。。。");
        singer.sing();
        System.out.println("结算费用，下一次合作预约。。。。。。");
    }
}

/**
 * @author IT楠老师
 * @date 2020/5/28
 */
public class Client {

    public static void main(String[] args) {
        Singer singer = new MaleSinger("鹿晗");
        Singer agent = new Agent(singer);
        agent.sing();
    }
}

public class Agent extends MaleSinger {

    private MaleSinger maleSinger;

    public void setMaleSinger(MaleSinger maleSinger) {
        this.maleSinger = maleSinger;
    }

    @Override
    public void sing() {
        System.out.println("开始唱歌了-----------");
        maleSinger.sing();
        System.out.println("结束唱歌了-----------");
    }
}

public static void main(String[] args) {
    MaleSinger maleSinger = new MaleSinger("鹿晗");
    Agent agent = new Agent();
    agent.setMaleSinger(maleSinger);
    agent.sing();
}

Object invoke(Object proxy, 方法 method, Object[] args)；
//参数
//proxy - 调用该方法的代理实例
//method -所述方法对应于调用代理实例上的接口方法的实例。方法对象的声明类将是该方法声明的接口，它可以是代理类继承该方法的代理接口的超级接口。
//args -包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。原始类型的参数包含在适当的原始包装器类的实例中，例如java.lang.Integer或java.lang.Boolean 。

Proxy.newProxyInstance(ClassLoader loader,
                       Class<?>[] interfaces,
                       InvocationHandler h)

/**
 * @author IT楠老师
 * @date 2020/5/21
 * 经纪人
 */
public class Agent implements InvocationHandler {

    private Singer singer;

    /**
     * 设置代理的经济人
     * @param singer
     */
    public void setSinger(Singer singer) {
        this.singer = singer;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("---------------经纪人把把关--------------");
        Object returnObj = method.invoke(singer, args);
        System.out.println("---------------唱完了收收钱------------------------");
        return returnObj;
    }

    /**
     * 获取一个代理对象
     * @return
     */
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                new Class[]{Singer.class},this);
    }
}

/**
 * @author IT楠老师
 * @date 2020/5/21
 */
public class Client {
    public static void main(String[] args) {

        MaleSinger luhan = new MaleSinger();

        Agent agent = new Agent();
        agent.setSinger(luhan);
        Singer singer = (Singer)agent.getProxy();

        singer.sing();
    }
}

//该设置用于输出jdk动态代理产生的类
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");   

public static void main(String[] args) {
    Enhancer enhancer=new Enhancer();
    enhancer.setSuperclass(MaleSinger.class);
    enhancer.setCallback(new MethodInterceptor() {
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
            System.out.println("---------");
            Object invoke = methodProxy.invokeSuper(o,objects);
            System.out.println("++++++++++");
            return invoke;
        }
    });
    MaleSinger maleSinger = (MaleSinger)enhancer.create();
    maleSinger.sing();
}

public static void main(String[] args) {
    Enhancer enhancer=new Enhancer();
    enhancer.setSuperclass(MaleSinger.class);
    enhancer.setCallback(new MethodInterceptor() {
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
            System.out.println("---------");
            Object invoke = methodProxy.invokeSuper(o,objects);
            System.out.println("++++++++++");
            return invoke;
        }
    });
    MaleSinger maleSinger = (MaleSinger)enhancer.create(new Class[]{String.class},new Object[]{"小李"});
    maleSinger.sing();
}

/**
    * All generated proxied methods call this method instead of the original method.
    * The original method may either be invoked by normal reflection using the Method object,
    * or by using the MethodProxy (faster).
    * @param obj "this", the enhanced object
    * @param method intercepted Method
    * @param args argument array; primitive types are wrapped
    * @param proxy used to invoke super (non-intercepted method); may be called
    * as many times as needed
    * @throws Throwable any exception may be thrown; if so, super method will not be invoked
    * @return any value compatible with the signature of the proxied method. Method returning void will ignore this value.
    * @see MethodProxy
    */    
   public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args,
                              MethodProxy proxy) throws Throwable;

//该设置用于输出cglib动态代理产生的类
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\class");

/**
 * 可以唱歌的
 */
public interface Singable {
  /**
   * 唱歌
   */
  void sing();
}

/**
 * 歌手
 */
public class Singer implements Singable {
  @Override
  public void sing() {
    System.out.println("I am singing...");
  }
}

/**
 * 自定义类加载器
 */
public class MyClassLoader extends ClassLoader {
  public MyClassLoader() {
    super(Thread.currentThread().getContextClassLoader());
  }

  /**
   * 将字节数组转化为Class对象
   *
   * @param name 类全名
   * @param data class数组
   * @return
   */
  public Class<?> defineClassForName(String name, byte[] data) {
    return this.defineClass(name, data, 0, data.length);
  }

}

/**
 * @author itnanls(微信)
 * 我们的服务： 一路陪跑，顺利就业
 */
public class SingerAgentDump implements Opcodes {

    // 生成一个class的字节数组
    public static byte[] dump() throws Exception {

        ClassWriter classWriter = new ClassWriter(0);
        FieldVisitor fieldVisitor;
        RecordComponentVisitor recordComponentVisitor;
        MethodVisitor methodVisitor;
        AnnotationVisitor annotationVisitor0;

        // 定义class版本1.8，访问权限，类名，继承类，实现接口等信息
        classWriter.visit(V1_8, ACC_PUBLIC | ACC_SUPER, "com/ydlclass/SingerAgent", null, "java/lang/Object", new String[]{"com/ydlclass/Singable"});

        classWriter.visitSource("SingerAgent.java", null);

        {
        // 定义私有属性
            fieldVisitor = classWriter.visitField(ACC_PRIVATE, "delegate", "Lcom/ydlclass/Singable;", null, null);
            fieldVisitor.visitEnd();
        }
        {
        // 定义构造器
            methodVisitor = classWriter.visitMethod(ACC_PUBLIC, "<init>", "(Lcom/ydlclass/Singable;)V", null, null);
            methodVisitor.visitParameter("delegate", 0);
            methodVisitor.visitCode();
            Label label0 = new Label();
            methodVisitor.visitLabel(label0);
            methodVisitor.visitLineNumber(10, label0);
            methodVisitor.visitVarInsn(ALOAD, 0);
            methodVisitor.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
            Label label1 = new Label();
            methodVisitor.visitLabel(label1);
            methodVisitor.visitLineNumber(11, label1);
            methodVisitor.visitVarInsn(ALOAD, 0);
            methodVisitor.visitVarInsn(ALOAD, 1);
            methodVisitor.visitFieldInsn(PUTFIELD, "com/ydlclass/SingerAgent", "delegate", "Lcom/ydlclass/Singable;");
            Label label2 = new Label();
            methodVisitor.visitLabel(label2);
            methodVisitor.visitLineNumber(12, label2);
            methodVisitor.visitInsn(RETURN);
            Label label3 = new Label();
            methodVisitor.visitLabel(label3);
            methodVisitor.visitLocalVariable("this", "Lcom/ydlclass/SingerAgent;", null, label0, label3, 0);
            methodVisitor.visitLocalVariable("delegate", "Lcom/ydlclass/Singable;", null, label0, label3, 1);
            methodVisitor.visitMaxs(2, 2);
            methodVisitor.visitEnd();
        }
        {
// 定义方法sing
            methodVisitor = classWriter.visitMethod(ACC_PUBLIC, "sing", "()V", null, null);
            methodVisitor.visitCode();
            Label label0 = new Label();
            methodVisitor.visitLabel(label0);
            methodVisitor.visitLineNumber(16, label0);
            methodVisitor.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
            methodVisitor.visitLdcInsn("before sing...");
            methodVisitor.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
            Label label1 = new Label();
            methodVisitor.visitLabel(label1);
            methodVisitor.visitLineNumber(17, label1);
            methodVisitor.visitVarInsn(ALOAD, 0);
            methodVisitor.visitFieldInsn(GETFIELD, "com/ydlclass/SingerAgent", "delegate", "Lcom/ydlclass/Singable;");
            methodVisitor.visitMethodInsn(INVOKEINTERFACE, "com/ydlclass/Singable", "sing", "()V", true);
            Label label2 = new Label();
            methodVisitor.visitLabel(label2);
            methodVisitor.visitLineNumber(18, label2);
            methodVisitor.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
            methodVisitor.visitLdcInsn("after sing...");
            methodVisitor.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
            Label label3 = new Label();
            methodVisitor.visitLabel(label3);
            methodVisitor.visitLineNumber(19, label3);
            methodVisitor.visitInsn(RETURN);
            Label label4 = new Label();
            methodVisitor.visitLabel(label4);
            methodVisitor.visitLocalVariable("this", "Lcom/ydlclass/SingerAgent;", null, label0, label4, 0);
            methodVisitor.visitMaxs(2, 1);
            methodVisitor.visitEnd();
        }
        classWriter.visitEnd();

        return classWriter.toByteArray();
    }

    // 将字节数组加载为class
    public static Singable newProxyInstance(Singable delegate) throws Exception {
        String className = "com.ydlclass.SingerAgent";
        byte[] classData = dump();
        Class<?> aClass = new MyClassLoader().defineClassForName(className, classData);
        return (Singable) aClass.getDeclaredConstructor(Singable.class).newInstance(delegate);
    }
}

/**
 * 歌手经纪人
 */
public class SingerAgent implements Singable {

  private Singable delegate;

  public SingerAgent(Singable delegate) {
    this.delegate = delegate;
  }

  @Override
  public void sing() {
    System.out.println("before sing...");
    delegate.sing();
    System.out.println("after sing...");
  }
}

public class Client {
  public static void main(String[] args) throws IOException {
    ASMifier.main(new String[]{SingerAgent.class.getName()});
  }
}

public class Client {
  public static void main(String[] args) throws Exception {
    Singable singerAgent = SingerAgentDump.newProxyInstance(new Singer());
    singerAgent.sing();
  }

}

before sing...
I am singing...
after sing...

// 将字节数组加载为class
public static SingerAgent newProxyInstance(Singable delegate) throws Exception {
    String className = "com.imooc.sourcecode.java.dynamicproxy.asm.test3.SingerAgent";
    byte[] classData = dump();
    Class<?> aClass = new MyClassLoader().defineClassForName(className, classData);
    return (SingerAgent) aClass.getDeclaredConstructor(Singable.class).newInstance(delegate);
  }

Exception in thread "main" java.lang.ClassCastException: class com.imooc.sourcecode.java.dynamicproxy.asm.test3.SingerAgent cannot be cast to class com.imooc.sourcecode.java.dynamicproxy.asm.test3.SingerAgent (com.imooc.sourcecode.java.dynamicproxy.asm.test3.SingerAgent is in unnamed module of loader com.imooc.sourcecode.java.dynamicproxy.asm.test3.MyClassLoader @4590c9c3; com.imooc.sourcecode.java.dynamicproxy.asm.test3.SingerAgent is in unnamed module of loader 'app')
    at com.imooc.sourcecode.java.dynamicproxy.asm.test3.SingerAgentDump.newProxyInstance(SingerAgentDump.java:98)
    at com.imooc.sourcecode.java.dynamicproxy.asm.test3.Client.main(Client.java:5)

/**
 * @author zn
 * @date 2021/1/25
 */


public class User implements Serializable {
    private int id;
    private String username;
    private String password;

    public User() {
    }

    public User(int id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

/**
 * @author zn
 * @date 2021/1/25
 */
public interface UserDao {

    Integer saveUser(User user);

    List<User> findUser(Integer id);
}

/**
 * 用于描述一个Dao的方法的必要条件
 * @author zn
 * @date 2021/1/25
 */
public class DaoWrapper {

    /**
     * 类型，insert|update|delete
     */
    private String type;
    /**
     * 返回值的类型
     */
    private String resultType;
    /**
     * 参数的类型
     */
    private String paramType;
    /**
     * sql语句
     */
    private String sql;

    public DaoWrapper(String type, String resultType, String paramType, String sql) {
        this.type = type;
        this.resultType = resultType;
        this.paramType = paramType;
        this.sql = sql;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getResultType() {
        return resultType;
    }

    public void setResultType(String resultType) {
        this.resultType = resultType;
    }

    public String getParamType() {
        return paramType;
    }

    public void setParamType(String paramType) {
        this.paramType = paramType;
    }

    public String getSql() {
        return sql;
    }

    public void setSql(String sql) {
        this.sql = sql;
    }

    @Override
    public String toString() {
        return "DaoWrapper{" +
                "type='" + type + '\'' +
                ", resultType='" + resultType + '\'' +
                ", paramType='" + paramType + '\'' +
                ", sql='" + sql + '\'' +
                '}';
    }
}

/**
 * 数据源工厂
 * 简单工厂的应用
 * @author zn
 * @date 2021/1/25
 */
public class DataSourceFactory {

    public static DataSource createDataSource(String type){

        DataSource dataSource = null;
        Properties properties = new Properties();
        if("hikari".equals(type)){
            try {
                properties.load(DataSourceFactory.class.getClassLoader().getResourceAsStream("hikari.properties"));
            } catch (IOException e) {
                e.printStackTrace();
            }
            HikariConfig hikariConfig = new HikariConfig(properties);
            dataSource = new HikariDataSource(hikariConfig);

        } else if ("druid".equals(type)){
            try {
                properties.load(DataSourceFactory.class.getClassLoader().getResourceAsStream("druid.properties"));
            } catch (IOException e) {
                e.printStackTrace();
            }
            DruidDataSource druidDataSource = new DruidDataSource();
            druidDataSource.configFromPropety(properties);
            dataSource = druidDataSource;
        }

        return dataSource;
    }

}

/**
 * 会话对象
 * @author zn
 * @date 2021/1/25
 */
public class Session {

    /**
     * 每个会话持有一个链接
     */
    private Connection connection;
    /**
     * 当前会话的上下文
     */
    private Map<String, Map<String, DaoWrapper>> env = new HashMap<>(8);

    public Session(Connection connection,Map<String, Map<String, DaoWrapper>> env) {
        this.connection = connection;
        this.env = env;
    }

    /**
     * 拿到一个包装类
     * @param clazz
     * @param <T>
     * @return
     */
    public <T> T getMapper(Class<T> clazz) {
        T t = (T) Proxy.newProxyInstance(this.getClass().getClassLoader(),
                new Class[]{clazz},
                new SQLHandler(connection, clazz,env.get(clazz.getName())));
        return t;
    }

    // 开始会话
    public void begin() {
        try {
            connection.setAutoCommit(false);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 提交
    public void commit() {
        try {
            connection.commit();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }


    // 回滚
    public void rollback() {
        try {
            connection.rollback();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

}

/**
 * @author zn
 * @date 2021/1/25
 */
public class SessionFactory {

    private DataSource dataSource;

    private Map<String, Map<String, DaoWrapper>> env = new HashMap<>(8);

    public SessionFactory(String config) {
        loadXml(config);
    }

    // 打开一个会话
    public Session openSession() {
        Connection connection = null;
        try {
            connection = dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return new Session(connection, env);
    }

    // 加载资源环境
    public void loadXml(String config) {
        try {
            SAXReader reader = new SAXReader();
            Document configDom = reader.read(Session.class.getClassLoader().getResourceAsStream(config));
            Element configRoot = configDom.getRootElement();
            String dataSourceType = configRoot.element("dataSource").getTextTrim();
            dataSource = DataSourceFactory.createDataSource(dataSourceType);

            List mapperElements = configRoot.elements("mapper");
            List<String> mapperPaths = new ArrayList<>();
            for (Object element : mapperElements) {
                Element mapper = (Element) element;
                mapperPaths.add(mapper.getTextTrim());
            }

            for (String mapperPath : mapperPaths) {
                Map<String, DaoWrapper> wrapper = new HashMap<>(2);
                Document document = reader.read(Session.class.getClassLoader().getResourceAsStream(mapperPath));
                Element root = document.getRootElement();
                String namespace = root.attribute("namespace").getValue();
                Iterator iterator = root.elementIterator();
                while (iterator.hasNext()) {
                    Element el = (Element) iterator.next();
                    String type = el.getName();
                    String id = el.attribute("id").getValue();
                    String resultType = el.attribute("resultType").getValue();
                    String paramType = el.attribute("paramType").getValue();
                    String sqlStr = el.getTextTrim();

                    wrapper.put(id, new DaoWrapper(type, resultType, paramType, sqlStr));
                }
                env.put(namespace, wrapper);
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        }

    }
}

/**
 * @author zn
 * @date 2021/1/25
 */
public class SQLHandler implements InvocationHandler {

    /**
     * 需传入一个链接
     */
    private Connection connection;
    /**
     * 需传入一个dao的类型
     */
    private Class clazz;
    /**
     * 需传入一个独立的环境
     */
    private Map<String, DaoWrapper> env;


    public SQLHandler(Connection connection, Class clazz,Map<String, DaoWrapper> env) {
        this.connection = connection;
        this.clazz = clazz;
        this.env = env;
    }

    /**
     * 生成代理对象
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        // 拿到包装
        DaoWrapper wrapper = env.get(method.getName());

        PreparedStatement statement = connection.prepareStatement(wrapper.getSql());

        // 对每一种sql语句进行独立的操作
        if ("insert".equals(wrapper.getType())) {
            String paramType = wrapper.getParamType();
            // 暂定传入一个对象
            Class<?> clazz = args[0].getClass();
            Field[] fields = clazz.getDeclaredFields();
            for (int i = 0; i < fields.length; i++) {
                fields[i].setAccessible(true);
                statement.setObject(i + 1, fields[i].get(args[0]));
            }
            return statement.executeUpdate();

        } else if ("delete".equals(wrapper.getType())) {
            for (int i = 0; i < args.length; i++) {
                statement.setObject(i + 1, args[i]);
            }
            return statement.executeUpdate();

        } else if ("select".equals(wrapper.getType())) {
            for (int i = 0; i < args.length; i++) {
                statement.setObject(i + 1, args[i]);
            }
            ResultSet result = statement.executeQuery();
            List list = new ArrayList();
            while (result.next()) {
                Class<?> clazz = Class.forName(wrapper.getResultType());
                Object object = clazz.newInstance();
                Field[] fields = clazz.getDeclaredFields();
                for (int i = 0; i < fields.length; i++) {
                    fields[i].setAccessible(true);
                    fields[i].set(object, result.getObject(fields[i].getName()));

                }
                list.add(object);
            }
            return list;
        }
        return null;
    }
}