設計模式的應用

/**
 *  單例 + 工廠 + 構造者 + 動態代理
 */
public class HandelrFactory {


    /**
     * 接口或者接口的實現類
     */
    private final Class<? extends IHandler> clazz;

    private final Object[] params;

    /**
     * 調用此方法 會調用靜態內部類 調用靜態屬性方法
     * @return
     */
    private static Builder newInstance(){
        return Instance.instance;
    }

    /**
     * 經過builder去調用方法 new對象
     * @return
     */
    public static Builder builder(){
        return newInstance();
    }

    private HandelrFactory(Class<? extends IHandler> clazz, Object ... params){
        this.params = params;
        this.clazz = clazz;
    }

    /**
     * 靜態內部類
     */
    private static class Instance {
        public static final Builder instance = new Builder();
    }

    /**
     * 運行方法
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    public void bind() throws IllegalAccessException, InstantiationException {
        //實例化字節碼
        IHandler myHandler = this.clazz.newInstance();
        //動態代理
        InvocationHandler invocationHandler = new MyInvocationHandler(myHandler);
        //代理對象  1. 用來指明生成代理對象使用哪一個類裝載器 2.Class<?>[] interfaces用來指明生成哪一個對象的代理對象 3. 用來指明產生的這個代理對象要作什麼事情
        IHandler result = (IHandler) Proxy.newProxyInstance(this.getClass().getClassLoader(), new Class[]{IHandler.class}, invocationHandler);
        //代理對象執行方法
        result.executor(this.params);
    }

    static class Builder {

        private Class<? extends IHandler> clazz;

        private Object[] params;

        /**
         * set方法1
         * @param clazz
         * @return
         */
        public Builder setClazz(Class<? extends IHandler> clazz){
            this.clazz = clazz;
            return this;
        }

        /**
         * set方法2
         * @param params
         * @return
         */
        public Builder setParams(Object ... params){
            this.params = params;
            return this;
        }

        /**
         * 根據傳入參數構建工廠
         * @return
         */
        public HandelrFactory build(){
            return new HandelrFactory(this.clazz, this.params);
        }

    }

    public static void main(String[] args) throws InstantiationException, IllegalAccessException {
        HandelrFactory
                .builder()
                .setClazz(MyHandlerImpl.class)
                .setParams("12345")
                .build()
                .bind();

        System.out.println();

        HandelrFactory
                .builder()
                .setClazz(MyHandlerImpl.class)
                .setParams("fdsfds")
                .build()
                .bind();
    }
}

 

接口：

public interface IHandler {

    Object executor(Object... param);
}

 

接口實現類：

public class MyHandlerImpl implements IHandler {

    @Override
    public Object executor(Object... param) {
        for(Object p: param){
            if (p instanceof String){
                System.out.println("我是接口實現類，我在執行方法");
               String paramValue = (String)p;
                System.out.println("方法的參數是"+paramValue);
            }
        }
        return null;
    }
}

動態代理類：

public class MyInvocationHandler implements InvocationHandler {

    //要加強的對象
    private Object target;

    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
        System.out.println("代理對象進行方法加強");
        //某個方法 加強的目標 參數
        method.invoke(target, args);
        return null;
    }
}