commons.box.app.AppBean Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of commons-box-app Show documentation
Common utils for BOX projects.
The newest version!
package commons.box.app;


import commons.box.app.bean.*;
import commons.box.app.internal.*;
import commons.box.util.Collects;
import commons.box.util.Logs;
import commons.box.util.Strs;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/**
 * 适应各种类型的bean operator实例 用于直接操作对象
 * 
 * 
创建作者：xingxiuyi 
 * 版权所属：xingxiuyi 
 */
@SuppressWarnings("unchecked")
public class AppBean implements BeanAccess {
    private final static AppLog LOG = Logs.get(AppBean.class);

    private final static BeanMetaAccess DEFAULT_META_BEAN_OP = InternalBeanMetaAccess.INSTANCE;
    private final static BeanMapAccess DEFAULT_MAP_BEAN_OP = InternalBeanMapAccess.INSTANCE;
    private final static BeanObjectAccess DEFAULT_OBJECT_BEAN_OP = InternalBeanObjectAccess.INSTANCE;

    private final static String[] EMPTY_NAMES = new String[]{};
    public static final String[] EMPTY_STRS = {};
    public static final Object[] EMPTY_ARRAY = {};
    public static final String DOT = ".";
    public static final String SP_DOT = "\\.";

    private final static AppBean BEAN_OP = new AppBean(true);
    private final static AppBean BEAN_SAFE_OP = new AppBean(false);

    /**
     * 返回实例(全局)
     * 
     * throwError表示在操作时发生异常是否抛出 如果不抛出则仅记录error日志
     *
     * @param throwError
     * @return
     */
    public final static AppBean inst(boolean throwError) {
        return throwError ? BEAN_OP : BEAN_SAFE_OP;
    }

    /**
     * 返回实例(全局)
     *
     * @return
     */
    public final static AppBean inst() {
        return BEAN_OP;
    }

    /**
     * 返回新创建的实例 (与inst方法不同,本方法每次调用均返回新创建的实例对象)
     * 

     * throwError表示在操作时发生异常是否抛出 如果不抛出则仅记录error日志
     *
     * @param throwError
     * @return
     */
    public static AppBean newinst(boolean throwError) {
        return new AppBean(throwError);
    }

    private final boolean throwError;

    private BeanMetaAccess metaBOP = DEFAULT_META_BEAN_OP;
    private BeanMapAccess mapBOP = DEFAULT_MAP_BEAN_OP;
    private BeanObjectAccess objectBOP = DEFAULT_OBJECT_BEAN_OP;

    public AppBean(boolean throwError) {
        this.throwError = throwError;
    }


    /**
     * 获取配置信息 在本方法中class请求占多数，提高其优先级
     *
     * @param meta
     * @param 
     * @return
     */
    @SuppressWarnings("unchecked")
    public  MetaAccess meta(Object meta) {
        if (meta instanceof Class) return AppClass.from((Class) meta).access();
        else if (meta instanceof MetaAccess) return (MetaAccess) meta;
        else if (meta instanceof MetaBean) return (MetaAccess) this.baMeta().config(((MetaBean) meta).config());
        else if (meta instanceof Map) return (MetaAccess) new InternalMapAccess((Map) meta);
        return null;
    }

    /**
     * 根据对象获取目标
     *
     * @param instance
     * @return 根据类型判断实例 总是不为空
     */
    public BeanAccess from(Object instance) {
        if (instance instanceof MetaBean) return this.baMeta();
        else if (instance instanceof DataObject) return this.baObject();
        else if (instance instanceof Map) return this.baMap();
        else if (instance instanceof Class) return this.fromType((Class) instance);
        else return this.baObject();
    }

    /**
     * 根据类获取目标
     *
     * @param type
     * @return 根据类型判断实例 总是不为空
     */
    @Nonnull
    public BeanAccess fromType(Class type) {
        if (type == null || DataObject.class.isAssignableFrom(type)) return this.baObject();
        else if (MetaBean.class.isAssignableFrom(type)) return this.baMeta();
        else if (Map.class.isAssignableFrom(type)) return this.baMap();
        else return this.baObject();
    }

    /**
     * 获取 metaBean 的 Factory
     *
     * @return
     */
    @Nonnull
    public List metaBeanFactories() {
        return this.baMeta().factories();
    }

    /**
     * 获取 Meta Bean Config 实例通过注册服务获取
     *
     * @param configID
     * @return
     */
    public MetaBeanConfig metaBeanConfig(String configID) {
        return this.baMeta().config(configID);
    }

    @Nonnull
    private BeanMetaAccess baMeta() {
        BeanMetaAccess bop = this.metaBOP;
        if (bop == null) return DEFAULT_META_BEAN_OP;
        return bop;
    }

    @Nonnull
    private BeanMapAccess baMap() {
        BeanMapAccess bop = this.mapBOP;
        if (bop == null) return DEFAULT_MAP_BEAN_OP;
        return bop;
    }

    @Nonnull
    private BeanObjectAccess baObject() {
        BeanObjectAccess bop = this.objectBOP;
        if (bop == null) return DEFAULT_OBJECT_BEAN_OP;
        return bop;
    }


    @Override
    public  T inst(Class type) throws AppError {
        if (this.throwError) {
            return this.fromType(type).inst(type);
        } else {
            try {
                return this.fromType(type).inst(type);
            } catch (Throwable e) {
                LOG.warn(e.getMessage(), e);
            }
        }
        return null;
    }

    /**
     * 可用于替换其它实现
     *
     * @param bop
     */
    public void setBeanMapAccess(BeanMapAccess bop) {
        if (bop == null) bop = DEFAULT_MAP_BEAN_OP;
        this.mapBOP = bop;
    }

    /**
     * 可用于替换其它实现
     *
     * @param bop
     */
    public void setBeanObjectAccess(BeanObjectAccess bop) {
        if (bop == null) bop = DEFAULT_OBJECT_BEAN_OP;
        this.objectBOP = bop;
    }

    /**
     * 可用于替换其它实现
     *
     * @param bop
     */
    public void setBeanMetaAccess(BeanMetaAccess bop) {
        if (bop == null) bop = DEFAULT_META_BEAN_OP;
        this.metaBOP = bop;

    }

    @Override
    public  O prop(T bean, String property) throws AppError {
        if (this.throwError) {
            if (bean == null) throw AppError.error("操作目标对象为空 无法操作");
            return this.from(bean).prop(bean, property);
        } else {
            if (bean == null) return null;
            try {
                return this.from(bean).prop(bean, property);
            } catch (Throwable e) {
                LOG.debug(e.getMessage(), e);
            }
        }
        return null;
    }

    @Override
    public  void prop(T bean, String property, O value) throws AppError {
        if (this.throwError) {
            if (bean == null) throw AppError.error("操作目标对象为空 无法操作");
            this.from(bean).prop(bean, property, value);
        } else {
            if (bean == null) return;
            try {
                this.from(bean).prop(bean, property, value);
            } catch (Throwable e) {
                LOG.warn(e.getMessage(), e);
            }
        }
    }

    @Override
    public  O field(T bean, String name) throws AppError {
        if (this.throwError) {
            if (bean == null) throw AppError.error("操作目标对象为空 无法操作");
            return this.from(bean).field(bean, name);
        } else {
            if (bean == null) return null;
            try {
                return this.from(bean).field(bean, name);
            } catch (Throwable e) {
                LOG.debug(e.getMessage(), e);
            }
        }
        return null;
    }

    @Override
    public  void field(T bean, String name, O value) throws AppError {
        if (this.throwError) {
            if (bean == null) throw AppError.error("操作目标对象为空 无法操作");
            this.from(bean).field(bean, name, value);
        } else {
            if (bean == null) return;
            try {
                this.from(bean).field(bean, name, value);
            } catch (Throwable e) {
                LOG.warn(e.getMessage(), e);
            }
        }
    }

    @Override
    public  R invoke(T bean, String method, Object... args) throws Throwable {
        if (this.throwError) {
            if (bean == null) throw AppError.error("操作目标对象为空 无法操作");
            return this.from(bean).invoke(bean, method, args);
        } else {
            if (bean == null) return null;
            try {
                return this.from(bean).invoke(bean, method, args);
            } catch (Throwable e) {
                LOG.warn(e.getMessage(), e);
            }
        }
        return null;
    }

    @Override
    public  boolean has(T bean, String name) {
        if (bean == null) return false;
        return this.from(bean).has(bean, name);
    }

    @Override
    public  boolean hasField(T bean, String name) {
        if (bean == null) return false;
        return this.from(bean).hasField(bean, name);
    }

    @Override
    public  boolean canInvoke(T bean, String method, Object... args) {
        if (bean == null) return false;
        return this.from(bean).canInvoke(bean, method, args);
    }

    @Override
    public  String[] props(T bean) {
        if (bean == null) return EMPTY_NAMES;
        return this.from(bean).props(bean);
    }

    @Override
    public  String[] fields(T bean) {
        if (bean == null) return EMPTY_NAMES;
        return this.from(bean).fields(bean);
    }

    /**
     * 获取值 与prop方法不同的是支持多级属性操作 如果props是多个元素 表示获取级联下级对象值
     *
     * @param bean
     * @param prop 属性名 如果是多个值表示级联属性
     * @param 
     * @param 
     * @return
     * @throws AppError
     */
    public  O get(T bean, String prop) throws AppError {
        if (this.throwError) {
            if (bean == null) throw AppError.error("操作目标对象为空 无法操作");
            return this.get(this.from(bean), bean, prop);
        } else {
            if (bean == null) return null;
            try {
                return this.get(this.from(bean), bean, prop);
            } catch (Throwable e) {
                LOG.debug(e.getMessage(), e);
            }
        }
        return null;
    }

    /**
     * 获取多个属性值  多级属性使用.分隔 表示获取级联下级对象值
     *
     * @param bean
     * @param props 属性名数组 多个属性对应所需获取的多个字段
     * @param 
     * @return
     * @throws AppError
     */
    public  Map mget(T bean, String... props) throws AppError {
        if (this.throwError) {
            if (bean == null) throw AppError.error("操作目标对象为空 无法操作");
            BeanAccess bo = this.from(bean);
            Map map = new LinkedHashMap<>();
            if (props != null) for (String p : props) map.put(p, this.get(bo, bean, p));
            return map;
        } else {
            if (bean == null) return null;
            BeanAccess bo = this.from(bean);
            Map map = new LinkedHashMap<>();

            if (props != null) for (String p : props) {
                try {
                    map.put(p, this.get(bo, bean, p));
                } catch (Throwable e) {
                    LOG.debug(e.getMessage(), e);
                }
            }

            return map;
        }
    }


    /**
     * 设置属性 与prop方法不同的是支持多级属性操作 如果props是多个元素 表示设置级联下级对象值 本方法自动创建中间缺失的对象 等同于autocreate=true
     *
     * @param 
     * @param 
     * @return
     * @throws AppError
     */
    public  AppBean set(T bean, String prop, O value) throws AppError {
        return this.set(bean, prop, value, true);
    }


    /**
     * 设置级联属性 与prop方法不同的是支持多级属性操作 如果props是多个元素 表示获取级联下级对象值
     * 
     * autocreate 用于控制是否 多级属性时要设置的中间值属性不存在则尝试创建
     *
     * @param bean
     * @param prop
     * @param value
     * @param autocreate 在多级属性时要设置的中间值属性不存在则尝试创建
     * @param 
     * @param 
     * @return
     * @throws AppError
     */
    public  AppBean set(T bean, String prop, O value, boolean autocreate) throws AppError {
        if (this.throwError) {
            if (bean == null) throw AppError.error("操作目标对象为空 无法操作");
            this.set(this.from(bean), bean, prop, value, autocreate);
        } else {
            if (bean == null) return null;
            try {
                this.set(this.from(bean), bean, prop, value, autocreate);
            } catch (Throwable e) {
                LOG.warn(e.getMessage(), e);
            }
        }
        return this;
    }


    /**
     * 设置多个属性值 多级属性使用.分隔 表示获取级联下级对象值
     *
     * @param bean
     * @param props
     * @param 
     * @return
     * @throws AppError
     */
    public  AppBean mset(T bean, Map props) throws AppError {
        return this.mset(bean, props, true);
    }


    /**
     * 设置多个属性值 多级属性使用.分隔 表示获取级联下级对象值 多级属性可以使用autocreate控制
     *
     * @param bean
     * @param props
     * @param autocreate
     * @param 
     * @return
     * @throws AppError
     */
    public  AppBean mset(T bean, Map props, boolean autocreate) throws AppError {// TODO
        if (this.throwError) {
            if (bean == null) throw AppError.error("操作目标对象为空 无法操作");
            BeanAccess bo = this.from(bean);
            if (props != null) for (Map.Entry me : props.entrySet()) {
                this.set(bo, bean, me.getKey(), me.getValue(), autocreate);
            }
        } else {
            if (bean == null) return null;
            BeanAccess bo = this.from(bean);
            if (props != null) for (Map.Entry me : props.entrySet()) {
                try {
                    this.set(bo, bean, me.getKey(), me.getValue(), autocreate);
                } catch (Throwable e) {
                    LOG.warn(e.getMessage(), e);
                }
            }
        }
        return this;
    }

    @SuppressWarnings("ConstantConditions")
    private  O get(BeanAccess bo, T bean, String prop) throws AppError {
        if (bo == null || bean == null || prop == null) return null;

        if (prop.contains(DOT)) {// 多级属性 TODO 对于 map 应该避免处理 . 分隔
            String[] props = Strs.split(prop, SP_DOT);

            if (props == null || props.length < 2) return bo.prop(bean, prop); // 仍使用基本属性prop
            else {
                Object pto = bean;
                BeanAccess pbo = bo;

                for (int i = 0; i < props.length; i++) {
                    String pn = props[i];

                    Object prevo = pto;
                    pto = pbo.prop(prevo, pn);
                    if (pto == null) return null;

                    pbo = from(pto);
                    if (pbo == null) return null;
                }

                return (O) pto;
            }
        } else return bo.prop(bean, prop);
    }

    private  void set(BeanAccess bo, T bean, String prop, O value, boolean autocreate) throws AppError {
        if (bo == null || bean == null || prop == null) return;

        if (prop.contains(DOT)) { // 多级属性
            String[] props = Strs.split(prop, SP_DOT);

            if (props.length < 2) bo.prop(bean, prop, value); // 仍使用基本属性prop
            else {
                Object pto = bean;
                BeanAccess pbo = bo;

                int lget = props.length - 1;

                for (int i = 0; i < lget; i++) {
                    String pn = props[i];
                    Object prevo = pto;
                    pto = pbo.prop(prevo, pn);

                    if (pto == null && autocreate) {
                        Class ptt = pbo.type(prevo, pn);
                        BeanAccess tmpbo = fromType(ptt);
                        if (tmpbo == null) throw AppError.error("类型 [" + bean.getClass() + "] 未能找到构建 " + prop);
                        pto = tmpbo.inst(ptt);
                        if (pto != null) pbo.prop(prevo, pn, pto);
                    }

                    // 即使自动创建后仍然为空 则抛出异常
                    if (pto == null) throw AppError.error("类型 [" + bean.getClass() + "] 未能设置属性 " + prop);

                    pbo = from(pto);
                    if (pbo == null) throw AppError.error("类型 [" + bean.getClass() + "] 未能操作属性 " + prop);
                }

                pbo.prop(pto, props[lget], value);
            }
        } else bo.prop(bean, prop, value);
    }

    @Override
    public  Class type(T bean, String prop) {
        return from(bean).type(bean, prop);
    }

    /**
     * 根据含.的多级属性生成分级的数组 用于多级数据的查找或设置
     * 总是不为空
     *
     * @param prop
     * @return
     */
    @SuppressWarnings("ConstantConditions")
    public static String[] split(String prop) {
        if (prop == null || prop.length() < 1) return EMPTY_STRS;
        if (!prop.contains(DOT)) return new String[]{prop};
        String[] props = Strs.split(prop, SP_DOT);
        return (props == null) ? EMPTY_STRS : props;
    }

    /**
     * 判断props是否包含多级属性
     *
     * @param props
     * @return
     */
    public static boolean hasInnerProps(String... props) {
        if (Collects.isEmpty(props)) return false;
        for (String p : props) if (Strs.contains(p, DOT)) return true;
        return false;
    }
}