1. 编写类型解析器

方案1：实现TypeHandler重写方法

package com.aliyun.kuxuandemo.typeHandler;

import org.apache.ibatis.type.*;

import java.sql.*;
import java.util.Arrays;
import java.util.List;

/**
 * Created with IntelliJ IDEA.
 *
 * @author: wb-zcx696752
 * @description:
 * @data: 2020/10/13 11:19 PM
 */

@MappedJdbcTypes(JdbcType.VARCHAR)
@MappedTypes(List.class)
public class ListTypeHandler implements TypeHandler<List<String>> {

    @Override
    public void setParameter(PreparedStatement ps, int i, List<String> parameter, JdbcType jdbcType) throws SQLException {
        StringBuffer sb = new StringBuffer();
        for (String pa : parameter) {
            sb.append(pa).append(",");
        }

        ps.setString(i, sb.toString().substring(0, sb.toString().length() - 1));
    }

    @Override
    public List<String> getResult(ResultSet resultSet, String s) throws SQLException {
        String[] split = resultSet.getString(s).split(",");
        return Arrays.asList(split);
    }

    @Override
    public List<String> getResult(ResultSet resultSet, int i) throws SQLException {
        String[] split = resultSet.getString(i).split(",");
        return Arrays.asList(split);
    }

    @Override
    public List<String> getResult(CallableStatement callableStatement, int i) throws SQLException {
        String[] split = callableStatement.getString(i).split(",");
        return Arrays.asList(split);
    }

}

方案二：继承BaseTypeHandler类，重写方法

package com.aliyun.kuxuandemo.typeHandler;

import org.apache.ibatis.type.BaseTypeHandler;
import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.MappedJdbcTypes;
import org.apache.ibatis.type.MappedTypes;

import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.List;

/**
 * Created with IntelliJ IDEA.
 *
 * @author: wb-zcx696752
 * @description:
 * @data: 2020/10/13 12:56 PM
 */
@MappedJdbcTypes(JdbcType.VARCHAR)
@MappedTypes(List.class)
public class ListTypeHandler extends BaseTypeHandler<List<String>> {
    @Override
    public void setNonNullParameter(PreparedStatement preparedStatement, int i, List<String> strings, JdbcType jdbcType) throws SQLException {
        //1.List集合转字符串
        StringBuffer sb = new StringBuffer();
        for (String string : strings) {
            sb.append(string).append(",");
        }
        //2.设置给ps
        preparedStatement.setString(i, sb.toString().substring(0, sb.toString().length() - 1));
    }

    @Override
    public List<String> getNullableResult(ResultSet resultSet, String s) throws SQLException {
        String[] split = resultSet.getString(s).split(",");
        return Arrays.asList(split);
    }

    @Override
    public List<String> getNullableResult(ResultSet resultSet, int i) throws SQLException {
        String[] split = resultSet.getString(i).split(",");
        return Arrays.asList(split);
    }

    @Override
    public List<String> getNullableResult(CallableStatement callableStatement, int i) throws SQLException {
        String[] split = callableStatement.getString(i).split(",");
        return Arrays.asList(split);
    }
}

2. 在mybatis-config.xml中注册该解析器

<typeHandlers>
        <typeHandler handler="com.aliyun.kuxuandemo.typeHandler.ListTypeHandler"/>
    </typeHandlers>

3.使用自定义类型解析器

查询时

@Select("select video_id,corp_id,oss_url,title,category_list,description from video_basic_info " +
            "where video_id=#{VideoID} and corp_id=#{CorpID}")
    @Results({
            @Result(property = "videoId", column = "video_id"),
            @Result(property = "corpId", column = "corp_id"),
            @Result(property = "ossUrl", column = "oss_url"),
            @Result(property = "categoryList", column = "category_list", typeHandler = com.aliyun.kuxuandemo.typeHandler.ListTypeHandler.class)
    })

插入修改时

@Update({
            "<script> ",
            "update video_basic_info ",
            "<set> ",
            "<if test = \"Title != null and Title != '' \"> ",
            "title=#{Title}, ",
            "</if> ",
            "<if test = \"Desc != null and Desc != '' \"> ",
            "description=#{Desc}, ",
            "</if> ",
            "<if test = \"Tag != null and Tag.size() > 0 \"> ",
            "category_list=#{Tag,javaType=List,jdbcType=VARCHAR,typeHandler=com.aliyun.kuxuandemo.typeHandler.ArrayTypeHandler} ",
            "</if> ",
            "</set> ",
            "where video_id=#{VideoID} and corp_id=#{CorpID}",
            "</script>"
    })
    int updateVideoBasicInfoTitleDescTag(BaseRequestParameterValidationModel parameter);

使用泛型和索引器来实现一个我们自己的集合类MyList
创建一个类MyList.cs继承接口IComparable

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace _005_List的创建和使用
{
    //使用泛型和索引器来实现一个我们自己的集合类MyList
    class MyList<T> where T : IComparable//继承接口(加一个约束)
    {
        private T[] array;
        private int count = 0; //表示当前的元素的个数

        //构造方法new MyList<T>(size)
        public MyList(int size)
        {
            if (size >= 0)
            {
                array = new T[size];
            }
        }

        public MyList()
        {
            array = new T[0];
        }

        //容量其实就是数组长度
        public int Capacity
        {
            get { return array.Length; }
        }

        //元素个数
        public int Count
        {
            get { return count; }
        }

        //添加元素
        public void Add(T item)
        {
            if (Count == Capacity) //判断元素个数跟列表容量大小是否一样大，如果一样大，说明数组容量不用，需要创建新的数组
            {
                if (Capacity == 0) //当数组长度为0的时候，创建一个长度为4的数组
                {
                    array = new T[4];
                }
                else
                {
                    var newArray = new T[Capacity * 2]; //当长度不为0的时候，我们创建一个长度为原来2倍的数组
                    Array.Copy(array, newArray, Count); //把旧数组中的元素复制到新的数组中 ， 复制前count个  array-->newArray
                    array = newArray; //数组是引用类型，newArray赋值给array的是堆中的储存地址
                }
            }
            array[Count] = item;
            count++;
        }

        //通过索引获取元素
        public T GetItem(int index)
        {
            if (index >= 0 && index < count)
            {
                return array[index];
            }
            else
            {
                throw new Exception("索引超出了范围");
            }
        }

        //创建索引器,索引器：通过[index]这种形式去访问数据，就是索引器
        public T this[int index]
        {
            get { return GetItem(index); }
            set
            {
                if (index >= 0 && index < count)
                {
                    array[index] = value;
                }
                else
                {
                    throw new Exception("索引超出了范围");
                }
            }
        }

        //插入元素
        public void Insert(int index, T item)
        {
            if (index >= 0 && index < count)
            {
                if (Count == Capacity)
                {
                    if (Capacity == 0)
                    {
                        array = new T[4];
                    }
                    else
                    {
                        var newArray = new T[Capacity * 2];
                        Array.Copy(array, newArray, Count);
                        array = newArray;
                    }

                    for (int i = count - 1; i >= index; i--)
                    {
                        array[i + 1] = array[i]; //把i位置的值放在后面，就是向后移动一个单位
                    }

                    array[index] = item;
                    count++;
                }
            }
            else
            {
                throw new Exception("索引超出了范围");
            }
        }

        //删除元素
        public void RemoveAt(int index)
        {
            if (index >= 0 && index < count)
            {
                for (int i = index + 1; i < count; i++)
                {
                    array[i - 1] = array[i];
                }
                count--;
            }
            else
            {
                throw new Exception("索引超出了范围");
            }
        }

        //从前（后）查找
        public int IndexOf(T item)
        {
            for (int i = 0; i < count; i++)
            {
                if (array[i].Equals(item))
                {
                    return i;
                }
            }

            return -1;
        }

        public int LastIndexOf(T item)
        {
            for (int i = Count - 1; i >= 0; i--)
            {
                if (array[i].Equals(item))
                {
                    return i;
                }
            }

            return -1;
        }

        //排序
        public void Sort()
        {
            for (int i = 0; i < Count - 1; i++)
            {
                if (array[i].CompareTo(array[i + 1]) > 0)//CompareTo返回值是int，返回值大于零表示前者大于后者，小于表示前者小于后者，等于零表示俩者相等
                {
                    T temp = array[i];
                    array[i] = array[i + 1];
                    array[i + 1] = temp;

                }
            }

        }

    }
}

在主方法调用自己定义的集合类 MyList

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace _005_List的创建和使用
{
    class Program
    {
        static void Main(string[] args)
        {
            MyList<int> mylist = new MyList<int>();
            //MyList<int> mylist2 = new MyList<int>(10);
            //添加元素
            mylist.Add(234);
            mylist.Add(24);
            mylist.Add(24);
            mylist.Add(274);
            ForList();//循环列表
            //插入元素
            mylist.Insert(2, 9000);
            ForList();//循环列表
            //访问元素个数
            Console.WriteLine(mylist.Count);
            //获取容量大小
            Console.WriteLine(mylist.Capacity);
            //移除指定位置的元素
            mylist.RemoveAt(2);
            ForList();//循环列表
            //IndexOf索引从第一个元素开始取得元素所在列表中的索引位置（LastIndexOf从后往前开始），查找不到返回-1
            Console.WriteLine(mylist.IndexOf(24));
            Console.WriteLine(mylist.LastIndexOf(24));
            Console.WriteLine(mylist.IndexOf(999));
            ForList();
            //排序
            mylist.Sort();
            ForList();
            Console.WriteLine();
            //mylist[0] = 100;//可以通过索引器 设置值
            //循环数组
            void ForList()
            {
                /*for (int i = 0; i < mylist.Count; i++)
                {
                    Console.WriteLine(mylist.GetItem(i));//通过GetItem方法取元素
                }*/
                

                for (int i = 0; i < mylist.Count; i++)
                {
                    Console.Write(mylist[i]+"  ");//通过索引器 取值
                }
                Console.WriteLine();

            }
            Console.ReadKey();
        }
    }
}

运行结果

背景

我有一个dto类，里面有一个int字段，一个list<String> 字段，一个list<dto2>字段，这个dto2字段里面也就一些long字段和string字段。

发生了什么

只能解析int字段，list<String> 字段，但是不能解析list<dto2>

干了什么事情

追了一波源码，发现解析int，list<dto2>都没有问题，唯独在解析list<dto2> 的时候发现这个字段反解析对象filedDeser为空

进入这个smartMatch(key)的方法，发现这个filedDeserializer为null

进入这个getFiledDeserializer方法发现，

解决方案

投向了google 的gson

DTO res = new GsonBuilder().create().fromJson(resStr, DTO.class);