`
Donald_Draper
  • 浏览: 984500 次
社区版块
存档分类
最新评论

Mybatis的MetaObject解析

阅读更多
SqlSessionFactory初始化:http://donald-draper.iteye.com/2331917
Mybatis加载解析Mapper(xml)文件第一讲:http://donald-draper.iteye.com/blog/2333125
Mybatis加载解析Mapper(xml)文件第二讲:http://donald-draper.iteye.com/blog/2333191
Mybatis 解析Mapper(class):http://donald-draper.iteye.com/blog/2333293
Mybatis的Environment解析详解:http://donald-draper.iteye.com/blog/2334133
mybatis 动态标签语句的解析(BoundSql):http://donald-draper.iteye.com/blog/2334135

在我们前面几篇文章中,经常出现一个类为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;
    }

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



//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();
    }

}
0
0
分享到:
评论

相关推荐

    mybatis3.x源码深度解析与最佳实践.pdf

    MetaObject 是 MyBatis 中的元对象,该对象负责将 Java 对象转换成 SQL 语句中可用的类型。 3.8 对象工厂 对象工厂是 MyBatis 中的核心对象之一,该对象负责将 Java 对象转换成 SQL 语句中可用的类型。 3.13 ...

    编写一个Mybatis插件 Mybatis脱敏插件.docx

    Mybatis提供了一个名为`MetaObject`的工具类,可以帮助我们方便地完成这些操作。例如,可以使用`MetaObject`来获取和修改`ResultSetHandler`的某些属性。 ```java MetaObject metaObject = MetaObject.forObject...

    reflection.zip

    下面我们将深入探讨MyBatis中的反射组件,包括MetaClass、ObjectWrapper和MetaObject这三个模块。 首先,让我们了解什么是反射。在Java中,反射是一种强大的机制,它允许程序在运行时检查和修改自身的行为。通过...

    mybatis分页插件

    `MetaObject`是Mybatis提供的一个工具类,用于方便地访问和修改对象的私有属性,即使没有getter和setter方法。它支持使用OGNL表达式来获取和设置属性值。在分页插件中,`MetaObject`被用来遍历和操作`...

    MyBatis-Plus 动态表名SQL解析器的实现

    public String handler(String tableName, MetaObject metaObject) { // 获取当前租户ID,这里假设是从请求上下文中获取 String tenantId = getCurrentTenantId(); // 根据租户ID生成表名,如 "table_" + ...

    后端开发框架 MyBatis四大核心对象之ParameterHandler.pdf

    - 如果参数对象是一个复杂的对象,则通过MetaObject获取其属性值。 - 如果参数对象为空,则设置参数值为null。 5. **类型处理**: - ParameterHandler依赖于TypeHandlerRegistry来处理不同类型的参数,确保参数...

    maven+SpringMvc+Mybatis+shiro安全框架整合实例(-)

    让我们逐一解析这些框架及其在项目中的作用。 1. Maven: Maven是Apache软件基金会开发的项目管理和综合工具,它通过POM(Project Object Model)文件管理项目的依赖关系,简化构建过程。在本实例中,Maven负责...

    java框架maven+springmvc+mybatis

    MyBatis与Spring结合使用时,可以实现DAO(Data Access Object)层的事务管理、自动装配和SqlSessionFactory的创建,使得数据库操作更加便捷。 **集成过程** 在"maven+springmvc+mybatis"的项目中,集成这三个框架...

    spring+springmvc+mybatis+mysql+maven+eclipse 工程实例

    SpringMVC通过DispatcherServlet接收请求,利用HandlerMapping找到合适的Controller,然后调用Controller处理逻辑,最后由ViewResolver解析视图并返回给客户端。 3. **MyBatis**:MyBatis是一个优秀的持久层框架,...

    springmvc +mybatis +maven 项目搭建demo

    通过定义POM(Project Object Model)文件,Maven可以自动下载所需的库,编译源代码,运行测试,打包项目,甚至部署到服务器。Maven的插件体系使得扩展功能变得简单,极大地方便了项目管理。 在这个"springmvc +...

    MyBatisInsider:MyBatis原始码阅读笔记

    MetaObjectParameterHandler,利用MetaObject系统进行参数处理。 8. **ResultSetHandler** ResultSetHandler负责处理SQL查询的结果。它将结果集转换为Java对象。DefaultResultSetHandler是默认实现,通过反射和...

    springmvc_day03_ssm.rar

    然后,MyBatis是一个轻量级的ORM(Object-Relational Mapping,对象关系映射)框架,它允许开发者用Java代码直接操作数据库。在SSM整合中,MyBatis与Spring结合,可以实现SQL的动态执行和结果映射。我们需要配置...

    ssm通过POI技术把excel数据导入mysql

    通过使用POI,我们可以解析Excel工作簿、工作表、单元格等元素,进而提取数据或填充数据。例如,你可以使用`HSSFWorkbook`来处理.xls文件,`XSSFWorkbook`来处理.xlsx文件。 在SSM框架中,我们通常会创建一个服务层...

    webservice客户端代码

    它为开发者提供了构建web应用程序的灵活框架,包括依赖注入(Dependency Injection, DI)、面向切面编程(Aspect-Oriented Programming, AOP)以及一系列控制器、视图解析器和模型对象的工具。Spring MVC的核心功能...

    java框架maven的demo

    6. **META-INF**目录:虽然在这个特定的示例中可能没有具体的内容,但在Maven项目中,这个目录通常用于存放MANIFEST.MF文件,该文件包含了关于JAR包的元数据,如作者、版本等信息。 要运行这个Demo,你需要在本地...

    ssm.rar_30sssm. com_ssm_ssm项目_完整ssm

    它通过DispatcherServlet接收请求,然后利用HandlerMapping找到对应的处理器,再由ModelAndView封装数据和视图,最后由ViewResolver解析并渲染视图。这样就实现了模型-视图-控制器的设计模式,使代码结构清晰,易于...

    test_java_exactly3ix_SSM框架_nan_ssm_

    2. **配置SpringMVC**:创建SpringMVC的配置文件,如servlet-context.xml,定义DispatcherServlet、视图解析器、拦截器等。同时,配置Controller,实现请求的映射和处理。 3. **配置MyBatis**:编写MyBatis的主配置...

    ssm-crud.rar文件

    在本项目中,开发者可能通过创建一个简单的数据模型(Entity),编写对应的DAO(Data Access Object)和Service,实现对数据库中数据的CRUD操作。 7. **项目构建**:SSM项目的构建通常包括以下步骤: - 创建数据库...

    精通spring4.x企业应用开发实战 源代码

    Spring支持多种数据库访问技术,包括JDBC、ORM(Object-Relational Mapping)框架如Hibernate和MyBatis。通过声明式事务管理,可以在不编写繁琐的事务控制代码的情况下,实现事务的正确处理。 5. **Spring Boot** ...

    rapid-framework v3.0.1.0 源码

    1. `Ognl.java`: 这个文件很可能是使用了Object-Graph Navigation Language (OGNL)库的一个实现或接口。OGNL是一种强大的表达式语言,常用于Java应用中,特别是那些基于MVC(模型-视图-控制器)架构的框架,如Struts...

Global site tag (gtag.js) - Google Analytics