工厂设计模式的思考

工厂模式对于开发者来说并不陌生，他利用多肽性很好的进行业务之间的解耦，不同的场景创建不同的实现，从而使得更多的关注业务实现,这种简单的实现这里不在举例。但是如果情形比较多的时候就会遇到问题，我们的工厂类就会产生大量的ifelse 进行判断，因此这时候就需要思考怎么样进行优化处理。

首先我结合平时的一个业务场景进行描述，简述下工厂设计模式。比如做一个秒批任务，接受来自第三方的服务，第三方申请成功后提交到系统，然后根据传入的事项进行校验个任务处理。真是情况，针对与不同的任务进行数据库动态配置进行处理，结合工厂模式进行设计实现，这里只描述工厂模式的应用。具体参考如下:

package com.szhome.study.factory;

/**
 * @Author caizl
 * @Description 事项业务接口
 * @Date 2024/01/08/17:48
 * @Version 1.0
 */
public interface IBussAdapter {
    public void check(String data);
    public String saveData(String data);
}

package com.szhome.study.factory.impl;

import com.szhome.study.factory.IBussAdapter;

/**
 * @Author caizl
 * @Description 海域业务
 * @Date 2024/01/08/17:47
 * @Version 1.0
 */
public class HyAdapter implements IBussAdapter {
    @Override
    public void check(String data) {
        System.out.println("海域校验通过"+data);
    }

    @Override
    public String saveData(String data) {
        System.out.println("海域办理通过" + data);
        return "ok";
    }
}

package com.szhome.study.factory.impl;

import com.szhome.study.factory.IBussAdapter;

/**
 * @Author caizl
 * @Description 合同实现
 * @Date 2024/01/08/17:47
 * @Version 1.0
 */
public class HtBussAdapter implements IBussAdapter {
    @Override
    public void check(String data) {
        System.out.println("合同事项校验通过");
    }

    @Override
    public String saveData(String data) {
        System.out.println("合同事项办理成功" + data);
        return "ok";
    }
}

package com.szhome.study.factory;

import com.szhome.study.util.ClassLoaderUtils;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * @Author caizl
 * @Description TODO
 * @Date 2024/01/08/17:51
 * @Version 1.0
 */
public class BussInvocationHandler implements InvocationHandler {
    //设置目标类
    public IBussAdapter iBussAdapter;
    public BussInvocationHandler(IBussAdapter iBussAdapter){
        this.iBussAdapter = iBussAdapter;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Class<?>[] clazzByArgs = ClassLoaderUtils.getClazzByArgs(args);
        Method targetmethod = IBussAdapter.class.getMethod(method.getName(), clazzByArgs);
        return targetmethod.invoke(iBussAdapter,args);
    }
}

package com.szhome.study.factory;

import java.lang.reflect.Proxy;

/**
 * @Author caizl
 * @Description TODO
 * @Date 2024/01/08/17:52
 * @Version 1.0
 */
public class JDKBussProxy {
    public static <T> T getProxy(Class<T> interfaces , IBussAdapter iBussAdapter){
        BussInvocationHandler bussInvocationHandler = new BussInvocationHandler(iBussAdapter);
        ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
        Class<?>[] interfaces1 = interfaces.getInterfaces();
        return (T)Proxy.newProxyInstance(contextClassLoader,new Class[]{interfaces1[0]},bussInvocationHandler);
    }
}
package com.szhome.study;

/**
 * @Author caizl
 * @Description TODO
 * @Date 2024/01/08/20:35
 * @Version 1.0
 */
public interface BussService {
    public void check(String data);
    public String saveData(String data);
}

package com.szhome.study.impl;

import com.szhome.study.BussService;

/**
 * @Author caizl
 * @Description TODO
 * @Date 2024/01/08/20:35
 * @Version 1.0
 */
public class BussServiceImpl implements BussService {
    @Override
    public void check(String check) {
        System.out.println("随便的服务检查");
    }

    @Override
    public String saveData(String check) {
        System.out.println("随便保存" + check);
        return "ok";
    }
}
  @Test
public void test_CacheService() throws Exception {
    //实现类通过配置进行创建
    BussService proxy = JDKBussProxy.getProxy(BussServiceImpl.class, new 
      HtBussAdapter());
        proxy.check("123");
        String data = proxy.saveData("123");
        System.out.println("测试保存结果：" + data);

}

通过接口编程，去除简单工厂的判断实现模式，采用统一接口服务，将统一接口服务创建代理工厂，通过传入的唯一表示创建实现类，从而动态的进行业务的解耦处理。