引用:https://www.cnblogs.com/yansum/p/5774873.html

Mybatis 高级结果映射 ResultMap Association Collection

在阅读本文章时，先说几个mybatis中容易混淆的地方：

1. mybatis中的列不是数据库里的列而是查询里的列，可以是别名（如 select user_name as userName,这时column=‘userName‘ property="userName"）

2.Mysql中使用自增主键时，useGeneratedKeys 用来获得自增主键填入类型对应的id属性，之后通过get方法得到

3.Map结尾是映射，Type是类型

resultType 和restltMap

restulyType:

1.对应的是java对象中的属性，大小写不敏感，

2.如果放的是java.lang.Map,key是查询语句的列名，value是查询的值，大小写敏感

resultMap:指的是定义好了的id的，是定义好的resyltType的引用

注意：用resultType的时候，要保证结果集的列名与java对象的属性相同，而resultMap则不用，而且resultMap可以用typeHander转换

4.

type:java 对象对应的类，

id:在本文件要唯一

column :数据库的列名或别名，

protery:对应java对象的属性

jdbcType:java.sql.Types

查询语句中，resultMap属性指向上面那个属性的标签的id

parameterType:参数类型，只能传一个参数，如果有多个参数要封装，如封装成一个类，要写包名加类名，基本数据类型则可以省略

5.一对1、一对多时，若有表的字段相同必须写别名，不然查询结果无法正常映射，出现某属性为空或者返回的结果与想象中的不同，而这往往是没有报错的。

6.若有意外中的错误，反复检查以上几点，和认真核查自己的sql语句，mapper.xml文件是否配置正确。

转：http://blog.csdn.net/ilovejava_2010/article/details/8180521，加上自己的总结

高级结果映射

MyBatis的创建基于这样一个思想：数据库并不是您想怎样就怎样的。虽然我们希望所有的数据库遵守第三范式或BCNF（修正的第三范式），但它们不是。如果有一个数据库能够完美映射到所有应用程序，也将是非常棒的，但也没有。结果集映射就是MyBatis为解决这些问题而提供的解决方案。

resultMap

·constructor–实例化的时候通过构造器将结果集注入到类中

oidArg– ID 参数; 将结果集标记为ID，以方便全局调用

oarg–注入构造器的结果集

·id–结果集ID，将结果集标记为ID，以方便全局调用

·result–注入一个字段或者javabean属性的结果

·association–复杂类型联合;许多查询结果合成这个类型

o嵌套结果映射– associations能引用自身,或者从其它地方引用,

·collection–复杂类型集合

o嵌套结果映射– collections能引用自身,或者从其它地方引用

·discriminator–使用一个结果值以决定使用哪个resultMap

ocase–基于不同值的结果映射

§嵌套结果映射–case也能引用它自身, 所以也能包含这些同样的元素。它也可以从外部引用resultMap

注意：

public class A{    private B b1;    private List<B> b2;}在映射b1属性时用association标签, 映射b2时用collection标签，分别是一对一，一对多的关系

id, result元素

<id property="id" column="post_id"/>

<result property="subject" column="post_subject"/>

这是最基本的结果集映射。id 和result 将列映射到属性或简单的数据类型字段(String, int, double, Date等)。

这两者唯一不同的是，在比较对象实例时id 作为结果集的标识属性。这有助于提高总体性能，特别是应用缓存和嵌套结果映射的时候。

Id、result属性如下：

支持的JDBC类型

MyBatis支持如下的JDBC类型：

Constructor元素

<constructor>

<idArg column="id" javaType="int"/>

<arg column=”username” javaType=”String”/>

</constructor>

当属性与DTO，或者与您自己的域模型一起工作的时候，许多场合要用到不变类。通常，包含引用，或者查找的数据很少或者数据不会改变的的表，适合映射到不变类中。构造器注入允许您在类实例化后给类设值，这不需要通过public方法。MyBatis同样也支持private属性和JavaBeans的私有属性达到这一点，但是一些用户可能更喜欢使用构造器注入。构造器元素可以做到这点。

考虑下面的构造器：

public class User {

//…

public User(int id, String username) {

//…

}

//…

}

为了将结果注入构造器，MyBatis需要使用它的参数类型来标记构造器。Java没有办法通过参数名称来反射获得。因此当创建constructor 元素，确保参数是按顺序的并且指定了正确的类型。

<constructor>

<idArg column="id" javaType="int"/>

<arg column=”username” javaType=”String”/>

</constructor>

其它的属性与规则与id、result元素的一样。

Association元素

<association property="author" column="blog_author_id" javaType=" Author">

<id property="id" column="author_id"/>

<result property="username" column="author_username"/>

</association>

Association元素处理“has-one”（一对一）这种类型关系。比如在我们的例子中，一个Blog有一个Author。联合映射与其它的结果集映射工作方式差不多，指定property、column、javaType（通常MyBatis会自动识别）、jdbcType（如果需要）、typeHandler。

不同的地方是您需要告诉MyBatis 如何加载一个联合查询。MyBatis使用两种方式来加载：

·Nested Select:通过执行另一个返回预期复杂类型的映射SQL语句（即引用外部定义好的SQL语句块）。

·Nested Results:通过嵌套结果映射（nested result mappings）来处理联接结果集（joined results）的重复子集。

首先，让我们检查一下元素属性。正如您看到的，它不同于普通只有select和resultMap属性的结果映射。

联合嵌套选择（Nested Select for Association）

例如:

[html] view plain copy

1. <resultMap id=”blogResult” type=”Blog”>
2. <association property="author" column="blog_author_id" javaType="Author"
3. select=”selectAuthor”/>
4. </resultMap>
5. <select id=”selectBlog” parameterType=”int” resultMap=”blogResult”>
6. SELECT * FROM BLOG WHERE ID = #{id}
7. </select>
8. <select id=”selectAuthor” parameterType=”int” resultType="Author">
9. SELECT * FROM AUTHOR WHERE ID = #{id}
10. </select>
11. <wbr>

我们使用两个select语句：一个用来加载Blog，另一个用来加载Author。Blog的resultMap 描述了使用“selectAuthor”语句来加载author的属性。

如果列名和属性名称相匹配的话，所有匹配的属性都会自动加载。

虽然这个方法简单，但是对于大数据集或列表查询，就不尽如人意了。这个问题被称为“N+1 选择问题”（N+1 Selects Problem）。概括地说，N+1选择问题是这样产生的：

·您执行单条SQL语句去获取一个列表的记录( “+1”)。

·对列表中的每一条记录，再执行一个联合select 语句来加载每条记录更加详细的信息(“N”)。

这个问题会导致成千上万的SQL语句的执行，因此并非总是可取的。

上面的例子，MyBatis可以使用延迟加载这些查询，因此这些查询立马可节省开销。然而，如果您加载一个列表后立即迭代访问嵌套的数据，这将会调用所有的延迟加载，因此性能会变得非常糟糕。

鉴于此，这有另外一种方式。

联合嵌套结果集（Nested Results for Association）

您已经在上面看到了一个非常复杂的嵌套联合的例子，接下的演示的例子会更简单一些。我们把Blog和Author表联接起来查询，而不是执行分开的查询语句：

1. <select id="selectBlog" parameterType="int" resultMap="blogResult">
2. select
3. B.id as blog_id,
4. B.title as blog_title,
5. B.author_id as blog_author_id,
6. A.id as author_id,
7. A.username as author_username,
8. A.password as author_password,
9. A.email as author_email,
10. A.bio as author_bio
11. from Blog B left outer join Author A on B.author_id = A.id
12. where B.id = #{id}
13. </select>

注意到这个连接（join），要确保所有的别名都是唯一且无歧义的。（为什么用别名呢？用别名的目的就是确保唯一无歧义。今天写了一段代码，没有返回List类型的结果集，检查了很久也没报错，最后加上别名，唯一区别开来就好了。估计是两个表中有个别字段歧义）这使映射容易多了，现在我们来映射结果集：

1. <resultMap id="blogResult" type="Blog">
2. <id property=”blog_id” column="id" />
3. <result property="title" column="blog_title"/>
4. <association property="author" column="blog_author_id" javaType="Author"
5. resultMap=”authorResult”/>
6. </resultMap>
7. <resultMap id="authorResult" type="Author">
8. <id property="id" column="author_id"/>
9. <result property="username" column="author_username"/>
10. <result property="password" column="author_password"/>
11. <result property="email" column="author_email"/>
12. <result property="bio" column="author_bio"/>
13. </resultMap>

在上面的例子中，您会看到Blog的作者（“author”）联合一个“authorResult”结果映射来加载Author实例。

重点提示:id元素在嵌套结果映射中扮演了非常重要的角色，您应该总是指定一个或多个属性来唯一标识这个结果集。事实上，如果您没有那样做，MyBatis也会工作，但是会导致严重性能开销。选择尽量少的属性来唯一标识结果，而使用主键是最明显的选择（即使是复合主键）。

上面的例子使用一个扩展的resultMap 元素来联合映射。这可使Author结果映射可重复使用。然后，如果您不需要重用它，您可以直接嵌套这个联合结果映射。下面例子就是使用这样的方式：

[html] view plain copy

1. <resultMap id="blogResult" type="Blog">
2. <id property=”blog_id” column="id" />
3. <result property="title" column="blog_title"/>
4. <association property="author" column="blog_author_id" javaType="Author">
5. <id property="id" column="author_id"/>
6. <result property="username" column="author_username"/>
7. <result property="password" column="author_password"/>
8. <result property="email" column="author_email"/>
9. <result property="bio" column="author_bio"/>
10. </association>
11. </resultMap>

在上面的例子中您已经看到如果处理“一对一”（“has one”）类型的联合查询。但是对于“一对多”（“has many”）的情况如果处理呢？这个问题在下一节讨论。

Collection元素

[html] view plain copy

1. <collection property="posts" ofType="domain.blog.Post">
2. <id property="id" column="post_id"/>
3. <result property="subject" column="post_subject"/>
4. <result property="body" column="post_body"/>
5. </collection>

collection元素的作用差不多和association元素的作用一样。事实上，它们非常相似，以至于再对相似点进行描述会显得冗余，因此我们只关注它们的不同点。

继续我们上面的例子，一个Blog只有一个Author。但一个Blog有许多帖子（文章）。在Blog类中，会像下面这样定义相应属性：

private List<Post> posts;

映射一个嵌套结果集到一个列表，我们使用collection元素。就像association 元素那样，我们使用嵌套查询，或者从连接中嵌套结果集。

集合嵌套选择（Nested Select for Collection）

首先我们使用嵌套选择来加载Blog的文章。

[html] view plain copy

1. <resultMap id=”blogResult” type=”Blog”>
2. <collection property="posts" javaType=”ArrayList” column="blog_id"
3. ofType="Post" select=”selectPostsForBlog”/>
4. </resultMap>
5. <select id=”selectBlog” parameterType=”int” resultMap=”blogResult”>
6. SELECT * FROM BLOG WHERE ID = #{id}
7. </select>
8. <select id=”selectPostsForBlog” parameterType=”int” resultType="Author">
9. SELECT * FROM POST WHERE BLOG_ID = #{id}
10. </select>

一看上去这有许多东西需要注意，但大部分看起与我们在association元素中学过的相似。首先，您会注意到我们使用了collection元素，然后会注意到一个新的属性“ofType”。这个元素是用来区别JavaBean属性（或者字段）类型和集合所包括的类型。因此您会读到下面这段代码。

<collection property="posts" javaType=”ArrayList” column="blog_id"

ofType="Post" select=”selectPostsForBlog”/>

è理解为:“一个名为posts，类型为Post的ArrayList集合（A collection of posts in an ArrayList of type Post）” 。

javaType属性不是必须的，通常MyBatis 会自动识别，所以您通常可以简略地写成：

<collection property="posts" column="blog_id" ofType="Post"

select=”selectPostsForBlog”/>

集合的嵌套结果集（Nested Results for Collection）

这时候，您可能已经猜出嵌套结果集是怎样工作的了，因为它与association非常相似，只不过多了一个属性“ofType”。

让我们看下这个SQL：

[sql] view plain copy

1. <select id="selectBlog" parameterType="int" resultMap="blogResult">
2. select
3. B.id as blog_id,
4. B.title as blog_title,
5. B.author_id as blog_author_id,
6. P.id as post_id,
7. P.subject as post_subject,
8. P.body as post_body,
9. from Blog B
10. left outer join Post P on B.id = P.blog_id
11. where B.id = #{id}
12. </select>

同样，我们把Blog和Post两张表连接在一起，并且也保证列标签名在映射的时候是唯一且无歧义的。现在将Blog和Post的集合映射在一起是多么简单：

[html] view plain copy

1. <resultMap id="blogResult" type="Blog">
2. <id property=”id” column="blog_id" />
3. <result property="title" column="blog_title"/>
4. <collection property="posts" ofType="Post">
5. <id property="id" column="post_id"/>
6. <result property="subject" column="post_subject"/>
7. <result property="body" column="post_body"/>
8. </collection>
9. </resultMap>

再次强调一下，id 元素是非常重要的。如果您忘了或者不知道id 元素的作用，请先读一下上面association一节。

如果希望结果映射有更好的可重用性，您可以使用下面的方式：

[html] view plain copy

1. <resultMap id="blogResult" type="Blog">
2. <id property=”id” column="blog_id" />
3. <result property="title" column="blog_title"/>
4. <collection property="posts" ofType="Post" resultMap=”blogPostResult”/>
5. </resultMap>
6. <resultMap id="blogPostResult" type="Post">
7. <id property="id" column="post_id"/>
8. <result property="subject" column="post_subject"/>
9. <result property="body" column="post_body"/>
10. </resultMap>

èNote:在您的映射中没有深度、宽度、联合和集合数目的限制。但应该谨记，在进行映射的时候也要考虑性能的因素。应用程序的单元测试和性能测试帮助您发现最好的方式可能要花很长时间。但幸运的是，MyBatis允许您以后可以修改您的想法，这时只需要修改少量代码就行了。

关于高级联合和集合映射是一个比较深入的课题，文档只能帮您了解到这里，多做一些实践，一切将很快变得容易理解。

Discriminator元素

<discriminator javaType="int" column="draft">

<case value="1" resultType="DraftPost"/>

</discriminator>

有时候一条数据库查询可能会返回包括各种不同的数据类型的结果集。Discriminator（识别器）元素被设计来处理这种情况，以及其它像类继承层次情况。识别器非常好理解，它就像java里的switch语句。

Discriminator定义要指定column和javaType属性。列是MyBatis将要取出进行比较的值，javaType用来确定适当的测试是否正确运行（虽然String在大部分情况下都可以工作），例：

[html] view plain copy

1. <resultMap id="vehicleResult" type="Vehicle">
2. <id property=”id” column="id" />
3. <result property="vin" column="vin"/>
4. <result property="year" column="year"/>
5. <result property="make" column="make"/>
6. <result property="model" column="model"/>
7. <result property="color" column="color"/>
8. <discriminator javaType="int" column="vehicle_type">
9. <case value="1" resultMap="carResult"/>
10. <case value="2" resultMap="truckResult"/>
11. <case value="3" resultMap="vanResult"/>
12. <case value="4" resultMap="suvResult"/>
13. </discriminator>
14. </resultMap>

在这个例子中，MyBatis将会从结果集中取出每条记录，然后比较它的vehicle type的值。如果匹配任何discriminator中的case，它将使用由case指定的resultMap。这是排它性的，换句话说，其它的case的resultMap将会被忽略（除非使用我们下面说到的extended）。如果没有匹配到任何case，MyBatis只是简单的使用定义在discriminator块外面的resultMap。所以，如果carResult像下面这样定义：

<resultMap id="carResult" type="Car">

<result property=”doorCount” column="door_count" />

</resultMap>

那么，只有doorCount属性会被加载。这样做是为了与识别器cases群组完全独立开来，哪怕它与上一层的resultMap一点关系都没有。在刚才的例子里我们当然知道cars和vehicles的关系，a Car is-a Vehicle。因此，我们也要把其它属性加载进来。我们要稍稍改动一下resultMap：

<resultMap id="carResult" type="Car"extends=”vehicleResult”>

<result property=”doorCount” column="door_count" />

</resultMap>

现在，vehicleResult和carResult的所有属性都会被加载。

可能有人会认为这样扩展映射定义有一点单调了，所以还有一种可选的更加简单明了的映射风格语法。例如：

[html] view plain copy

1. <resultMap id="vehicleResult" type="Vehicle">
2. <id property=”id” column="id" />
3. <result property="vin" column="vin"/>
4. <result property="year" column="year"/>
5. <result property="make" column="make"/>
6. <result property="model" column="model"/>
7. <result property="color" column="color"/>
8. <discriminator javaType="int" column="vehicle_type">
9. <case value="1" resultType="carResult">
10. <result property=”doorCount” column="door_count" />
11. </case>
12. <case value="2" resultType="truckResult">
13. <result property=”boxSize” column="box_size" />
14. <result property=”extendedCab” column="extended_cab" />
15. </case>
16. <case value="3" resultType="vanResult">
17. <result property=”powerSlidingDoor” column="power_sliding_door" />
18. </case>
19. <case value="4" resultType="suvResult">
20. <result property=”allWheelDrive” column="all_wheel_drive" />
21. </case>
22. </discriminator>
23. </resultMap>

è记住：对于这么多的结果映射，如果您不指定任何的结果集，那么MyBatis 会自动地将列名与属性相匹配。所以上面所举的例子比实际中需要的要详细。尽管如此，大部分数据库有点复杂，并且它并不是所有情况都是完全可以适用的。

Cache元素

MyBatis包含一个强大的、可配置、可定制的查询缓存机制。MyBatis 3 的缓存实现有了许多改进，使它更强大更容易配置。默认的情况，缓存是没有开启，除了会话缓存以外，它可以提高性能，且能解决循环依赖。开启二级缓存，您只需要在SQL映射文件中加入简单的一行：

<cache/>

这句简单的语句作用如下：

·所有映射文件里的select语句的结果都会被缓存。

·所有映射文件里的insert、update和delete语句执行都会清空缓存。

·缓存使用最近最少使用算法(LRU)来回收。

·缓存不会被设定的时间所清空。

·每个缓存可以存储1024 个列表或对象的引用（不管查询方法返回的是什么）。

·缓存将作为“读/写”缓存，意味着检索的对象不是共享的且可以被调用者安全地修改，而不会被其它调用者或者线程干扰。

所有这些特性都可以通过cache元素进行修改。例如：

<cache

eviction="FIFO"

flushInterval="60000"

size="512"

readOnly="true"/>

这种高级的配置创建一个每60秒刷新一次的FIFO 缓存，存储512个结果对象或列表的引用，并且返回的对象是只读的。因此在不用的线程里的调用者修改它们可能会引用冲突。

可用的回收算法如下：

·LRU–最近最少使用：移出最近最长时间内都没有被使用的对象。

·FIFO–先进先出：移除最先进入缓存的对象。

·SOFT–软引用: 基于垃圾回收机制和软引用规则来移除对象（空间内存不足时才进行回收）。

·WEAK–弱引用:基于垃圾回收机制和弱引用规则（垃圾回收器扫描到时即进行回收）。

默认使用LRU。

flushInterval：设置任何正整数，代表一个以毫秒为单位的合理时间。默认是没有设置，因此没有刷新间隔时间被使用，在语句每次调用时才进行刷新。

Size：属性可以设置为一个正整数，您需要留意您要缓存对象的大小和环境中可用的内存空间。默认是1024。

readOnly：属性可以被设置为true 或false。只读缓存将对所有调用者返回同一个实例。因此这些对象都不能被修改，这可以极大的提高性能。可写的缓存将通过序列化来返回一个缓存对象的拷贝。这会比较慢，但是比较安全。所以默认值是false。

使用自定义缓存

除了上面已经定义好的缓存方式，您能够通过您自己的缓存实现来完全重写缓存行为，或者通过创建第三方缓存解决方案的适配器。

<cache type=”com.domain.something.MyCustomCache”/>

这个例子演示了如果自定义缓存实现。由type指定的类必须实现org.mybatis.cache.Cache接口。这个接口是MyBatis框架比较复杂的接口之一，先给个示例：

[java] view plain copy

1. public interface Cache {
2. String getId();
3. int getSize();
4. void putObject(Object key, Object value);
5. Object getObject(Object key);
6. boolean hasKey(Object key);
7. Object removeObject(Object key);
8. void clear();
9. ReadWriteLock getReadWriteLock();
10. }

要配置您的缓存，简单地添加一个公共的JavaBeans 属性到您的缓存实现中，然后通过cache 元素设置属性进行传递，下面示例，将在您的缓存实现上调用一个setCacheFile(String file)方法。

<cache type=”com.domain.something.MyCustomCache”>

<property name=”cacheFile” value=”/tmp/my-custom-cache.tmp”/>

</cache>

您可以使用所有简单的JavaBeans属性，MyBatis会自动进行转换。

需要牢记的是一个缓存配置和缓存实例都绑定到一个SQL Map 文件命名空间。因此，所有的这个相同命名空间的语句也都和这个缓存绑定。语句可以修改如何与这个缓存相匹配，或者使用两个简单的属性来完全排除它们自己。默认情况下，语句像下面这样来配置：

<select ... flushCache=”false” useCache=”true”/>

<insert ... flushCache=”true”/>

<update ... flushCache=”true”/>

<delete ... flushCache=”true”/>

因为有默认值，所以您不需要使用这种方式明确地配置这些语句。如果您想改变默认的动作，只需要设置flushCache和useCache 属性即可。举个例子来说，在许多的场合下您可能排除缓存中某些特定的select语句。或者您想用select语句清空缓存。同样的，您也可能有一些update 语句在执行的时候不需要清空缓存。

cache-ref元素

回想上一节，我们仅仅只是讨论在某一个命名空间里使用或者刷新缓存。但有可能您想要在不同的命名空间里共享同一个缓存配置或者实例。在这种情况下，您就可以使用cache-ref 元素来引用另外一个缓存。

<cache-ref namespace=”com.someone.application.data.SomeMapper”/>

例子：

接下来看下一个完整的sqlmap可以运行的ibatis文件：

[html] view plain copy

1. <?xml version="1.0" encoding="UTF-8" ?>
2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
3. <mapper namespace="com.chudong.xy.dao.item.IItemDao">
4. <resultMap type="Item" id="itemResultMap" >
5. <id property="id" column="id" />
6. <result property="numIid" column="num_iid" />
7. <result property="title" column="title" />
8. <result property="subTitle" column="sub_title" />
9. <result property="cat" column="cat" />
10. <result property="picUrl" column="pic_url" />
11. <result property="picThumUrl" column="pic_thum_url" />
12. <result property="outerId" column="outer_id" />
13. <result property="props" column="props" />
14. <result property="marketPrice" column="market_price" />
15. <result property="price" column="price" />
16. <result property="num" column="num" />
17. <result property="listTime" column="list_time" />
18. <result property="delistTime" column="delist_time" />
19. <result property="sales" column="sales" />
20. <result property="created" column="created" />
21. <result property="modified" column="modified" />
22. <result property="enableStatus" column="enable_status" />
23. </resultMap>
24. <!-- 与活动和搭配套餐进行关联 -->
25. <resultMap type="Item" id="itemDetailResultMap" extends="itemResultMap">
26. <association property="active" column="id" javaType="com.chudong.xy.domain.active.Active" select="selectActive"/>
27. <collection property="withPackages" column="id" javaType="java.util.ArrayList" ofType="com.chudong.xy.domain.item.Item" select="selectWithPackages"/>
28. </resultMap>
29. <resultMap type="Active" id="activeResultMap">
30. <id property="id" column="id" />
31. <result property="title" column="title" />
32. <result property="picUrl" column="pic_url" />
33. </resultMap>
34. <!-- 查询单个商品,并装载活动和搭配套餐 -->
35. <select id="queryDetailById" parameterType="long" resultMap="itemDetailResultMap">
36. SELECT * from item where id = #{id} and enable_status = 1
37. </select>
38. <!-- 根据商品id得到一个活动 -->
39. <select id="selectActive" parameterType="long" resultMap="activeResultMap">
40. select id,title,pic_url from active where id = (select active_id from active_item where item_id = #{id} and enable_status=1 limit 0,1)
41. </select>
42. <!-- 根据商品id得到搭配套餐中的商品 -->
43. <select id="selectWithPackages" parameterType="long" resultMap="itemResultMap">
44. select * from item where id in(select mapping_id from item_relation where item_id = #{id} and type=1 and enable_status=1)
45. </select>
46. </mapper>

java类：

[java] view plain copy

1. public class Item implements Serializable {
2. /**
3. *
4. */
5. private static final long serialVersionUID = 3969923837162162882L;
6. /**
7. *
8. */
9. private Long id;
10. /**
11. * 商品编码
12. */
13. private Long numIid;
14. /**
15. * 商品标题
16. */
17. private String title;
18. /**
19. * 副标题
20. */
21. private String subTitle;
22. /**
23. * 商品类目，
24. */
25. private Integer cat;
26. /**
27. * 商品主图地址
28. */
29. private String picUrl;
30. /**
31. * 商品缩略图
32. */
33. private String picThumUrl;
34. /**
35. * 商家编码，
36. */
37. private String outerId;
38. /**
39. * 商品属性
40. */
41. private String props;
42. /**
43. * 销售价格
44. */
45. private Double price;
46. /**
47. * 商品的市场价格
48. */
49. private Double marketPrice;
50. /**
51. * 商品数量
52. */
53. private Integer num;
54. /**
55. * 商品上架时间
56. */
57. private Date listTime;
58. /**
59. * 商品下架时间
60. */
61. private Date delistTime;
62. /**
63. * 商品销量
64. */
65. private Integer sales;
66. private Date created;
67. private Date modified;
68. /**
69. * 数据可用状态，0表示不可用，1表示可用
70. */
71. private Integer enableStatus;
72. /**
73. * 商品的url，不存储数据库
74. */
75. private String itemTaobaoUrl;
76. /**
77. * 商品所关联的活动
78. */
79. private Active active;
80. /**
81. * 该商品的搭配套餐
82. */
83. private List<Item> withPackages;
84. //省略了set get方法
85. }