Mybatis的MetaObject解析

最新推荐文章于 2024-08-30 10:15:00 发布
最新推荐文章于 2024-08-30 10:15:00 发布
阅读量3.4k 收藏 4
点赞数
分类专栏： Mybatis 文章标签： Mybatis MetaObejct
SqlSessionFactory初始化：[url]http://donald-draper.iteye.com/2331917[/url]
Mybatis加载解析Mapper（xml）文件第一讲:[url]http://donald-draper.iteye.com/blog/2333125[/url]
Mybatis加载解析Mapper（xml）文件第二讲：[url]http://donald-draper.iteye.com/blog/2333191[/url]
Mybatis 解析Mapper（class）：[url]http://donald-draper.iteye.com/blog/2333293[/url]
Mybatis的Environment解析详解：[url]http://donald-draper.iteye.com/blog/2334133[/url]
mybatis 动态标签语句的解析（BoundSql）：[url]http://donald-draper.iteye.com/blog/2334135[/url]

在我们前面几篇文章中，经常出现一个类为MetaObject，今天我们就来看看，MetaObject的作用在讲Environments解析的时候有这么一段代码，设置数据源的属性 
public void setProperties(Properties properties)
    {
        Properties driverProperties = new Properties();
	//获取dataSource的对象描述
        MetaObject metaDataSource = SystemMetaObject.forObject(dataSource);
	//获取dataSource的所有属性，并设置
        for(Iterator i$ = properties.keySet().iterator(); i$.hasNext();)
        {
            Object key = i$.next();
            String propertyName = (String)key;
            if(propertyName.startsWith("driver."))
            {
                String value = properties.getProperty(propertyName);
                driverProperties.setProperty(propertyName.substring(DRIVER_PROPERTY_PREFIX_LENGTH), value);
            } else
            if(metaDataSource.hasSetter(propertyName))
            {
                String value = (String)properties.get(propertyName);
                Object convertedValue = convertValue(metaDataSource, propertyName, value);
                metaDataSource.setValue(propertyName, convertedValue);
            }
        }
        //设置metaDataSource的driverProperties属性
        if(driverProperties.size() > 0)
            metaDataSource.setValue("driverProperties", driverProperties);
    }

我们可以看到有这么几句代码 
 MetaObject metaDataSource = SystemMetaObject.forObject(dataSource);
 metaDataSource.hasSetter(propertyName)
 metaDataSource.setValue("driverProperties", driverProperties);

来看一下SystemMetaObject 
public class SystemMetaObject
{
    public static final ObjectFactory DEFAULT_OBJECT_FACTORY;
    public static final ObjectWrapperFactory DEFAULT_OBJECT_WRAPPER_FACTORY;
    public static final MetaObject NULL_META_OBJECT;
    private static class NullObject
    {
        private NullObject()
        {
        }
    }
    public static MetaObject forObject(Object object)
    {
        return MetaObject.forObject(object, DEFAULT_OBJECT_FACTORY, DEFAULT_OBJECT_WRAPPER_FACTORY);
    }


    static 
    {
        DEFAULT_OBJECT_FACTORY = new DefaultObjectFactory();
        DEFAULT_OBJECT_WRAPPER_FACTORY = new DefaultObjectWrapperFactory();
        NULL_META_OBJECT = MetaObject.forObject(org/apache/ibatis/reflection/SystemMetaObject$NullObject, DEFAULT_OBJECT_FACTORY, DEFAULT_OBJECT_WRAPPER_FACTORY);
    }
}

从上面的SystemMetaObject，我们可以看出，SystemMetaObject返回对象的MetaObject对象，实际上通过的MetaObject的forObject方法。

//Sql包装类 
public class BoundSql
{
    public BoundSql(Configuration configuration, String sql, List parameterMappings, Object parameterObject)
    {
        this.sql = sql;
        this.parameterMappings = parameterMappings;
        this.parameterObject = parameterObject;
        additionalParameters = new HashMap();
        metaParameters = configuration.newMetaObject(additionalParameters);
    }
    private String sql;
    private List parameterMappings;
    private Object parameterObject;
    private Map additionalParameters;
    private MetaObject metaParameters;
}

在Sql包装类，我们可以看到一下几句代码： 
metaParameters = configuration.newMetaObject(additionalParameters);
 //Configuration新建MetaObject对象
  public MetaObject newMetaObject(Object object)
    {
        return MetaObject.forObject(object, objectFactory, objectWrapperFactory);
    }

下面来看MetaObject
//MetaObject,设置Class实例属性 
public class MetaObject
{
    private Object originalObject;//原始Obeject
    private ObjectWrapper objectWrapper;//包装后的Object
    private ObjectFactory objectFactory;
    private ObjectWrapperFactory objectWrapperFactory;
    private MetaObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory)
    {
        originalObject = object;
        this.objectFactory = objectFactory;
        this.objectWrapperFactory = objectWrapperFactory;
        if(object instanceof ObjectWrapper)
            objectWrapper = (ObjectWrapper)object;
        else
	//如果对应objectWrapperFactory中存在，则返回object
        if(objectWrapperFactory.hasWrapperFor(object))
            objectWrapper = objectWrapperFactory.getWrapperFor(this, object);
        else
        if(object instanceof Map)
	    //Map
            objectWrapper = new MapWrapper(this, (Map)object);
        else
        if(object instanceof Collection)
	    //List
            objectWrapper = new CollectionWrapper(this, (Collection)object);
        else
	   //bean
            objectWrapper = new BeanWrapper(this, object);
    }
    //构造MetaObject
    public static MetaObject forObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory)
    {
        if(object == null)
            return SystemMetaObject.NULL_META_OBJECT;
        else
            return new MetaObject(object, objectFactory, objectWrapperFactory);
    }
    public String findProperty(String propName, boolean useCamelCaseMapping)
    {
        return objectWrapper.findProperty(propName, useCamelCaseMapping);
    }
    //获取可读属性名
    public String[] getGetterNames()
    {
        return objectWrapper.getGetterNames();
    }
     //获取可写属性名
    public String[] getSetterNames()
    {
        return objectWrapper.getSetterNames();
    }
    //获取对象属性name对应的值
     public Object getValue(String name)
    {
        PropertyTokenizer prop = new PropertyTokenizer(name);
        if(prop.hasNext())
        {
            MetaObject metaValue = metaObjectForProperty(prop.getIndexedName());
            if(metaValue == SystemMetaObject.NULL_META_OBJECT)
                return null;
            else
                return metaValue.getValue(prop.getChildren());
        } else
        {
            return objectWrapper.get(prop);
        }
    }
    //给对象属性name设置value值
    public void setValue(String name, Object value)
    {
        PropertyTokenizer prop = new PropertyTokenizer(name);
        if(prop.hasNext())
        {
            MetaObject metaValue = metaObjectForProperty(prop.getIndexedName());
            if(metaValue == SystemMetaObject.NULL_META_OBJECT)
            {
                if(value == null && prop.getChildren() != null)
                    return;
                metaValue = objectWrapper.instantiatePropertyValue(name, prop, objectFactory);
            }
            metaValue.setValue(prop.getChildren(), value);
        } else
        {
            objectWrapper.set(prop, value);
        }
    }
}

下面我们先来看forObject方法 
private MetaObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory)
    {
        originalObject = object;
        this.objectFactory = objectFactory;
        this.objectWrapperFactory = objectWrapperFactory;
        if(object instanceof ObjectWrapper)
            objectWrapper = (ObjectWrapper)object;
        else
	//如果对应objectWrapperFactory中存在，则返回object
        if(objectWrapperFactory.hasWrapperFor(object))
            objectWrapper = objectWrapperFactory.getWrapperFor(this, object);
        else
        if(object instanceof Map)
	    //Map
            objectWrapper = new MapWrapper(this, (Map)object);
        else
        if(object instanceof Collection)
	    //List
            objectWrapper = new CollectionWrapper(this, (Collection)object);
        else
	   //bean
            objectWrapper = new BeanWrapper(this, object);
    }
    //构造MetaObject
    public static MetaObject forObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory)
    {
        if(object == null)
            return SystemMetaObject.NULL_META_OBJECT;
        else
            return new MetaObject(object, objectFactory, objectWrapperFactory);
    }
//DefaultObjectWrapperFactory
 public class DefaultObjectWrapperFactory
    implements ObjectWrapperFactory
{
    public boolean hasWrapperFor(Object object)
    {
        return false;
    }
    public ObjectWrapper getWrapperFor(MetaObject metaObject, Object object)
    {
        throw new RuntimeException("The DefaultObjectWrapperFactory should never be called to provide an ObjectWrapper.");
    }
}

从MetaObject的forObject方法，我们可以看出，实际上，MetaObject的构造函数
MetaObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory)是把原始Obejct包装成ObjectWrapper（ObjectWrapper，MapWrapper，CollectionWrapper，BeanWrapper）,
如果ObjectWrapperFactory已经包装了Object，则通过ObjectWrapperFactory的 getWrapperFor(MetaObject metaObject, Object object)返回相应的ObjectWrapper。

在来看获取属性值方法，这里我们来看BeanWrapper 
public String findProperty(String propName, boolean useCamelCaseMapping)
{
     return objectWrapper.findProperty(propName, useCamelCaseMapping);
}

//BeanWrapper 
public class BeanWrapper extends BaseWrapper
{
    private Object object;
    private MetaClass metaClass;//Object对应的Class
    public BeanWrapper(MetaObject metaObject, Object object)
    {
        super(metaObject);
        this.object = object;
        metaClass = MetaClass.forClass(object.getClass());
    }
    //获取属性name对应的属性名
      public String findProperty(String name, boolean useCamelCaseMapping)
    {
        return metaClass.findProperty(name, useCamelCaseMapping);
    }
}

//MetaClass 
public class MetaClass
{
    private Reflector reflector;
    public static MetaClass forClass(Class type)
    {
        return new MetaClass(type);
    }
     private MetaClass(Class type)
    {
        //获取type类型对应的Reflector
        reflector = Reflector.forClass(type);
    } 
    //获取name对应的属性名，useCamelCaseMapping是否是驼峰命名
     public String findProperty(String name, boolean useCamelCaseMapping)
    {
        if(useCamelCaseMapping)
            name = name.replace("_", "");
        return findProperty(name);
    }
    public String findProperty(String name)
    {
        StringBuilder prop = buildProperty(name, new StringBuilder());
        return prop.length() <= 0 ? null : prop.toString();
    } 
     private StringBuilder buildProperty(String name, StringBuilder builder)
    {
        PropertyTokenizer prop = new PropertyTokenizer(name);
        if(prop.hasNext())
        {
            String propertyName = reflector.findPropertyName(prop.getName());
            if(propertyName != null)
            {
                builder.append(propertyName);
                builder.append(".");
                MetaClass metaProp = metaClassForProperty(propertyName);
                metaProp.buildProperty(prop.getChildren(), builder);
            }
        } else
        {
            String propertyName = reflector.findPropertyName(name);
            if(propertyName != null)
                builder.append(propertyName);
        }
        return builder;
    }
}

//Reflector 
public class Reflector
{
    private static boolean classCacheEnabled = true;
    private static final String EMPTY_STRING_ARRAY[] = new String[0];
    private static final Map REFLECTOR_MAP = new ConcurrentHashMap();
    private Class type;
    private String readablePropertyNames[];
    private String writeablePropertyNames[];
    private Map setMethods;
    private Map getMethods;
    private Map setTypes;
    private Map getTypes;
    private Constructor defaultConstructor;
    private Map caseInsensitivePropertyMap;
    //构造Class对应的Reflector
    public static Reflector forClass(Class clazz)
    {
        if(classCacheEnabled)
        {
	    //如果缓存状态开启，则从REFLECTOR_MAP获取对应的Reflector，没有则重新构建
            Reflector cached = (Reflector)REFLECTOR_MAP.get(clazz);
            if(cached == null)
            {
                cached = new Reflector(clazz);
                REFLECTOR_MAP.put(clazz, cached);
            }
            return cached;
        } else
        {
            return new Reflector(clazz);
        }
    }
    private Reflector(Class clazz)
    {
        readablePropertyNames = EMPTY_STRING_ARRAY;//可读属性名
        writeablePropertyNames = EMPTY_STRING_ARRAY;//可写属性名
        setMethods = new HashMap();//Set方法Map
        getMethods = new HashMap();//Get方法Map
        setTypes = new HashMap();
        getTypes = new HashMap();
        caseInsensitivePropertyMap = new HashMap();//大小写不敏感属性Map
        type = clazz;
        addDefaultConstructor(clazz);
        addGetMethods(clazz);
        addSetMethods(clazz);
        addFields(clazz);
        readablePropertyNames = (String[])getMethods.keySet().toArray(new String[getMethods.keySet().size()]);
        writeablePropertyNames = (String[])setMethods.keySet().toArray(new String[setMethods.keySet().size()]);
        //将可读属性添加大小写不敏感属性Map
	String arr$[] = readablePropertyNames;
        int len$ = arr$.length;
        for(int i$ = 0; i$ < len$; i$++)
        {
            String propName = arr$[i$];
            caseInsensitivePropertyMap.put(propName.toUpperCase(Locale.ENGLISH), propName);
        }
        //将可写属性添加大小写不敏感属性Map
        arr$ = writeablePropertyNames;
        len$ = arr$.length;
        for(int i$ = 0; i$ < len$; i$++)
        {
            String propName = arr$[i$];
            caseInsensitivePropertyMap.put(propName.toUpperCase(Locale.ENGLISH), propName);
        }

    }
     public String findPropertyName(String name)
    {
        return (String)caseInsensitivePropertyMap.get(name.toUpperCase(Locale.ENGLISH));
    }
}

回到MetaObject，再看获取属性get与setName的属性 
 public String[] getGetterNames()
    {
        return objectWrapper.getGetterNames();
    }
    public String[] getSetterNames()
    {
        return objectWrapper.getSetterNames();
    }

再看BeanWrapper的相应方法，并委托给MetaClass对应方法
//BeanWrapper 
public String[] getGetterNames()
    {
        return metaClass.getGetterNames();
    }

    public String[] getSetterNames()
    {
        return metaClass.getSetterNames();
    }

// MetaClass对应方法委托给Reflector 
 public String[] getGetterNames()
    {
        return reflector.getGetablePropertyNames();
    }

    public String[] getSetterNames()
    {
        return reflector.getSetablePropertyNames();
    }

再看Reflector 
public String[] getGetablePropertyNames()
    {
        return readablePropertyNames;
    }

    public String[] getSetablePropertyNames()
    {
        return writeablePropertyNames;
    }

实际上返回的是可读与可写属性名字符串组；
回到MetaObject，再看获取对象属性name对应的值 
 public Object getValue(String name)
    {
        PropertyTokenizer prop = new PropertyTokenizer(name);
        if(prop.hasNext())
        {
            MetaObject metaValue = metaObjectForProperty(prop.getIndexedName());
            if(metaValue == SystemMetaObject.NULL_META_OBJECT)
                return null;
            else
                return metaValue.getValue(prop.getChildren());
        } else
        {
            return objectWrapper.get(prop);
        }
    }

//BeanWrapper 
public Object get(PropertyTokenizer prop)
    {
        if(prop.getIndex() != null)
        {
            Object collection = resolveCollection(prop, object);
            return getCollectionValue(prop, collection);
        } else
        {
	    //获取bean对应的属性
            return getBeanProperty(prop, object);
        }
    }

通过MetaClass获取属性对应的get方法，调用相应的方法 
private Object getBeanProperty(PropertyTokenizer prop, Object object)
    {
        Invoker method = metaClass.getGetInvoker(prop.getName());
        return method.invoke(object, NO_ARGUMENTS);
        throw ExceptionUtil.unwrapThrowable(t);
        throw new ReflectionException((new StringBuilder()).append("Could not get property '").append(prop.getName()).append("' from ").append(object.getClass()).append(".  Cause: ").append(t.toString()).toString(), t);
    }

//BaseWrapper 
protected Object getCollectionValue(PropertyTokenizer prop, Object collection)
    {
        if(collection instanceof Map)
            return ((Map)collection).get(prop.getIndex());
        int i = Integer.parseInt(prop.getIndex());
        if(collection instanceof List)
            return ((List)collection).get(i);
        if(collection instanceof Object[])
            return ((Object[])(Object[])collection)[i];
        if(collection instanceof char[])
            return Character.valueOf(((char[])(char[])collection)[i]);
        if(collection instanceof boolean[])
            return Boolean.valueOf(((boolean[])(boolean[])collection)[i]);
        if(collection instanceof byte[])
            return Byte.valueOf(((byte[])(byte[])collection)[i]);
        if(collection instanceof double[])
            return Double.valueOf(((double[])(double[])collection)[i]);
        if(collection instanceof float[])
            return Float.valueOf(((float[])(float[])collection)[i]);
        if(collection instanceof int[])
            return Integer.valueOf(((int[])(int[])collection)[i]);
        if(collection instanceof long[])
            return Long.valueOf(((long[])(long[])collection)[i]);
        if(collection instanceof short[])
            return Short.valueOf(((short[])(short[])collection)[i]);
        else
            throw new ReflectionException((new StringBuilder()).append("The '").append(prop.getName()).append("' property of ").append(collection).append(" is not a List or Array.").toString());
    }

// MetaClass的获取属性的Get方法，委托给Reflector 
public Invoker getGetInvoker(String name)
    {
        return reflector.getGetInvoker(name);
    }

再看Reflector
从get方法Map中，获取对应的Invoker 
public Invoker getGetInvoker(String propertyName)
    {
        Invoker method = (Invoker)getMethods.get(propertyName);
        if(method == null)
            throw new ReflectionException((new StringBuilder()).append("There is no getter for property named '").append(propertyName).append("' in '").append(type).append("'").toString());
        else
            return method;
    }

回到MetaObject，再看给对象属性name设置value值 
public void setValue(String name, Object value)
    {
        PropertyTokenizer prop = new PropertyTokenizer(name);
        if(prop.hasNext())
        {
            MetaObject metaValue = metaObjectForProperty(prop.getIndexedName());
            if(metaValue == SystemMetaObject.NULL_META_OBJECT)
            {
                if(value == null && prop.getChildren() != null)
                    return;
                metaValue = objectWrapper.instantiatePropertyValue(name, prop, objectFactory);
            }
            metaValue.setValue(prop.getChildren(), value);
        } else
        {
            objectWrapper.set(prop, value);
        }
    }

//BeanWrapper 
public void set(PropertyTokenizer prop, Object value)
    {
        if(prop.getIndex() != null)
        {
            Object collection = resolveCollection(prop, object);
            setCollectionValue(prop, collection, value);
        } else
        {
	    //设置bean属性
            setBeanProperty(prop, object, value);
        }
    }

//获取bean属性对应的set方法，并设置 
private void setBeanProperty(PropertyTokenizer prop, Object object, Object value)
    {
        try
        {
            Invoker method = metaClass.getSetInvoker(prop.getName());
            Object params[] = {
                value
            };
            try
            {
                method.invoke(object, params);
            }

        }
    }

// MetaClass，获取set方法，委托给Reflector 
 public Invoker getSetInvoker(String name)
    {
        return reflector.getSetInvoker(name);
    }
再看Reflector，从setMethods方法Map中，获取Invoker
public Invoker getSetInvoker(String propertyName)
    {
        Invoker method = (Invoker)setMethods.get(propertyName);
        if(method == null)
            throw new ReflectionException((new StringBuilder()).append("There is no setter for property named '").append(propertyName).append("' in '").append(type).append("'").toString());
        else
            return method;
    }

总结：
[color=blue]从上面可以看出，MetaObject是用于包装Object的，将Object包装成ObjectWrapper，MapWrapper，CollectionWrapper，BeanWrapper等，ObjectWrapper是对应属性及方法的一个包装类，MetaObject获取obejct的属性值，以及给属性设置，是委托给
ObjectWrapper，ObjectWrapper在委托给MetaClass，MetaClass最后交Reflector；Reflector包含Obejct的属性名，set方法，以及get方法的描述，MetaObject获取属性值和设置属性值方法，本质上是，从Reflector获取属性对应方法的Invoker，然后invoke。下面一节，我们讲Reflector。[/color]


//PropertyTokenizer 
public class PropertyTokenizer
    implements Iterable, Iterator
{

    private String name;
    private String indexedName;
    private String index;
    private String children;
    public PropertyTokenizer(String fullname)
    {
        int delim = fullname.indexOf('.');
        if(delim > -1)
        {
            name = fullname.substring(0, delim);
            children = fullname.substring(delim + 1);
        } else
        {
            name = fullname;
            children = null;
        }
        indexedName = name;
        delim = name.indexOf('[');
        if(delim > -1)
        {
            index = name.substring(delim + 1, name.length() - 1);
            name = name.substring(0, delim);
        }
    }
    public String getName()
    {
        return name;
    }
    public String getIndex()
    {
        return index;
    }
    public String getIndexedName()
    {
        return indexedName;
    }
    public String getChildren()
    {
        return children;
    }
    public boolean hasNext()
    {
        return children != null;
    }
    public PropertyTokenizer next()
    {
        return new PropertyTokenizer(children);
    }
    public void remove()
    {
        throw new UnsupportedOperationException("Remove is not supported, as it has no meaning in the context of properties.");
    }

    public Iterator iterator()
    {
        return this;
    }
    public volatile Object next()
    {
        return next();
    }

}
iteye_11587
关注
专栏目录
MyBatis内置XML元素解析器解析自定义标签——快速掌握MyBatis自定义标签开发
AI天才研究院
07-28 1717
作为一个技术人员，一定要懂得把自己的知识通过有效的表达传递给他人。我认为把自己的知识通过文章的方式进行传播是非常有必要的。这也是技术博客文章的重要性。MyBatis 是 Apache 基金会的一个开源项目，它是一个优秀的持久层框架，可以用于 Java 的应用开发。MyBatis 提供了强大的映射工具，使得数据库操作变得简单而方便。MyBatis 在 MyBatis-Spring 中也提供了 Spring 和 MyBatis 之间的集成支持。
MyBatis之MetaObject
thebigdipperbdx的博客
10-09 878
MyBatis官方文档 MyBatis官方文档 ORM框架 源码 public class MetaObject { private final Object originalObject; private final ObjectWrapper objectWrapper; private final ObjectFactory objectFactory; privat...
MyBatis MetaObject
seasonsbin的专栏
05-13 597
1.操作Bean的字段 Bean: public class ShouldGetAndSetField { /** * 无getter/setter 叫字段 * 有getter/setter 叫属性 * 假设我们现在要操作一个私有字段 * */ private String simpleField; } Test Case: @Test @DisplayName("get/set目标对象的私有字段值") void shouldGetAnd...
MyBatis-Plus MetaObjectHandler 深入解析
最新发布
WenZhang的博客
08-30 1613
的主要功能是在数据库操作（如插入和更新）时自动填充实体类中的字段，特别是那些不需要用户手动赋值的字段。它的典型应用场景包括创建时间、更新时间、操作人等公共字段的自动填充。除了默认策略外，开发者还可以通过和方法自定义字段的填充逻辑。默认情况下，这些方法会在字段为空时才进行填充，避免覆盖已有值。是 MyBatis-Plus 提供的一个功能强大的接口，允许开发者在插入和更新操作中自动填充公共字段，从而减少代码重复，提升开发效率。
Mybatis中的MetaObject
liming0025的专栏
07-26 1891
在mybatis中，ResultSetHandler在收集JDBC返回的结果后需要转换成对应的Bean对象，其实映射的原理基本大家都能想到使用的时候java中的反射机制，但是在Mybatis中，提供了一个更加强大的对象，就是MetaObject，使用这个对象不仅对Bean中的属性赋值、取值都十分简单，同时还能对嵌套对象进行操作。 简单使用 可以看到，整个MateObject让设置和获取类的属性更加方便了，在工作中可以当做工具类直接使用。 底层结构 MetaObject -> Be...
Qt学习之路(10): Meta-Object系统
weixin_33701251的博客
09-06 144
前面说过，Qt使用的是自己的预编译器，它提供了对C++的一种扩展。利用Qt的信号槽机制，就可以把彼此独立的模块相互连接起来，不需要实现知道模块的任何细节。 为了达到这个目的，Qt提出了一个Meta-Object系统。它提供了两个关键的作用：信号槽和内省。 面向对象程序设计里面会讲到Smalltalk语言有一个元类系统。所谓元类，就是这里所说的Meta-Clas...
【mybatis】MetaObject解读
大乐乐
03-21 721
MetaObject作为 MyBatis 中的一个核心组件，通过封装复杂的反射操作和提供统一的接口，极大地提高了开发效率和运行性能。通过深入理解和合理利用MetaObject，可以更加灵活和高效地在 MyBatis 中进行数据处理。
mybatis源码解读(九)：reflection 包下 MetaObject、Reflector、MetaClass详解
qq_41063182的博客
07-13 2902
功能 reflection 包下的类主要负责的功能是 mybatis 反射实例化对象以及赋值，mybatis之所以可以将返回结果封装成pojo实体类，都是通过reflection包下的相关类通过反射去完成这个操作的。reflection 包下有几个核心的类，MetaObject、Reflector、MetaClass、以及ObjectWrapper。 它的这个设计思路是，首先将一个class的所有的字段、方法、构造等信息全部都存在 reflector 中，然后再通过 metaObject 的静态方法构造一个
mybatis3.x源码深度解析与最佳实践.pdf
09-12
MetaObject 是 MyBatis 中的元对象，该对象负责将 Java 对象转换成 SQL 语句中可用的类型。 3.8 对象工厂 对象工厂是 MyBatis 中的核心对象之一，该对象负责将 Java 对象转换成 SQL 语句中可用的类型。 3.13 ...
Mybatis动态表名SQL解析器
WannaRunning的博客
01-07 715
水平分表的方式对大数据量表的优化是有一定作用的。但是从分布式的角度来讲感觉并没有削减当前库的压力，所以水平分表适合对大数据量表做优化。 水平分表基于表结构一直，根据某些字段划分不同数据存在不同的表中，提高数据查询的效率。例如一张庞大的订单信息表，可以根据订单类型或者日期划分为多个表，Mybatis中使用动态表名拦截器的方式动态指定目标表名称进行查询。 下面的示例，对替换目标CAP_DOCUMENT_CATALOG表明自定义逻辑动态决定最终查询的表名进行替换后查询目标表数据 @Configuratio
【Mybatis源码分析】Mybatis中的反射（MetaObject）详细讲解
qq_63691275的博客
04-01 2534
文章总结：可以通过MetaObject对象对实例对象属性赋值和获取；ObjectFactory工厂对象可拓展；PropertyTokenizer类用了迭代器设计模式，对属性名进行操作迭代；BeanWrapper依赖MetaClass，MetaClass依赖反射工厂对象和反射对象；Reflector对象是对实例对象构造器、getter、setter方法、属性名等的封装；编写Bean对象的时候，应该遵循Bean规范，使得get后和set后可以和属性名
java.lang.NoClassDefFoundError: Could not initialize class com.github.pagehelper.util.MetaObjectUtil
你就像甜甜的益达
02-15 4121
使用mybatis的分页插件出现错误=-=,百度好长时间,发现MetaObject这个类,在高版本删除了=-=, 所以把版本换一下就好了. &lt;!-- 出现错误的版本--&gt; &lt;mybatis-version&gt;3.2.6&lt;/mybatis-version&gt; &lt;mybatis.spring-version&gt;1.2.2&lt;/mybatis.spr...
MyBatis的MetaObject解析
Zn昕的博客
03-15 3776
Mybatis 的 MetaObject 解析 MetaObject 源码 源码部分 public class MetaObject { private final Object originalObject; private final ObjectWrapper objectWrapper; private final ObjectFactory objectFact...
9.MetaObject
wangbo199308的博客
09-21 1947
1.MetaObject功能 MetaObject类相当于一个工具类，Mybatis在sql参数设置和结果集映射里经常使用到这个对象。 映射是指结果集中的列填充至JAVA Bean属性。这就必须用到反射，而Bean的属性 多种多样的有普通属性、对象、集合、Map都有可能。为了更加方便的操作Bean的属性，MyBatis提供了MeataObject 工具类，其简化了对象属性的操作。其具体功能如下： 查找属性：勿略大小写，支持驼峰、支持子属性 如：blog.comment.user_name（需要开启use
mybatis metaObject 详解
weixin_44243138的博客
06-06 990
MetaObject类相当于一个对象工具类，Mybatis在sql参数设置和结果集映射里经常使用到这个对象。映射是指结果集中的列填充至JAVA Bean属性。这就必须用到反射，而Bean的属性 多种多样的有普通属性、对象、集合、Map都有可能。为了更加方便的操作Bean的属性，MyBatis提供了MeataObject 工具类，其简化了对象属性的操作。1.1 metaObject的使用实体类@Data/**名称*//*** id*/测试。
【深入理解MyBatis】- 06Mybatis 源对象MetaObject使用
dengjili的专栏
07-28 3407
MetaObject简介 MetaObject对象是Mybatis框架用于访问对象属性的工作类，底层实现为java的反射基础。目前只支持JavaBean、Collection、Map三种类型对象访问，也可以自定义其他类型 Bean访问例子 public class BeanTest { public static void main(String[] args) { Person person = new Person(); MetaObject metaObject = SystemMetaOb
java metaobject_Java Configuration.newMetaObject方法代码示例
weixin_42099087的博客
02-24 262
import org.apache.ibatis.session.Configuration; //导入方法依赖的package包/类/*** 对SQL参数(?)设值,参考org.apache.ibatis.executor.parameter.* DefaultParameterHandler** @param ps* 表示预编译的 SQL 语句的对象。* @param m...
SpringBoot + Mybatis系列之插件机制 Interceptor
小灰灰blog的专栏
08-09 1362
【SpringBoot + Mybatis系列】插件机制 Interceptor 在 Mybatis 中，插件机制提供了非常强大的扩展能力，在 sql 最终执行之前，提供了四个拦截点，支持不同场景的功能扩展 Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed) ParameterHandler (getParameterObject, setParameters) Re..
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值