经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Spring Boot » 查看文章
Mybatis总结之如何自动生成数据库表结构
来源：cnblogs　　作者：Dream Young　　时间：2019/11/1 14:18:47　　对本文有异议

一般情况下，用Mybatis的时候是先设计表结构再进行实体类以及映射文件编写的，特别是用代码生成器的时候。

但有时候不想用代码生成器，也不想定义表结构，那怎么办？

这个时候就会想到Hibernate，然后想到它的hibernate.hbm2ddl.auto配置项。

所以手工创表的问题可以很方便的迅速用Hibernate来解决。 那有人问啦：有就是不想用Hibernate才换的Mybatis，你这又兜回去了吗？

其实不是的，我们需要的就是单单一个hbm2ddl功能。

其实应该这么想：有一款工具能够自动根据注解的实体类来生成各种数据库相应的表结构，只需要加几个jar包  (经测试后只要7个）并且 少量配置(3个配置项） 。

这款工具就是Hibernate。为什么不能是它呢！！！

原理说来也是超级的简单：   加入hibernate的包，程序开始时初始化一下hibernate的SessionFactory并清除它。

示例：

需要的Hibernate相关的JAR包 (本例基于Hibernate5.0.7，仅需要7个）：

          hibernate-core-5.0.7.Final.jar

          hibernate-commons-annotations-5.0.1.Final.jar

          hibernate-jpa-2.1-api-1.0.0.Final.jar

          geronimo-jta_1.1_spec-1.1.1.jar

          jboss-logging-3.3.0.Final.jar

          dom4j-1.6.1.jar

          javassist-3.18.1-GA.jar

Hibernate.cfg.xml文件：（去掉多余的，精简后的内容）

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE hibernate-configuration PUBLIC
  3.     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
  4.     "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
  5. <hibernate-configuration>
  6.     <session-factory>
  7.         <!--不采用InnoDB方式加快速度 -->
  8.         <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
  9.  
  10.         <!-- 注意update方式时对于属性的删减并不会删除数据库字段 -->
  11.         <property name="hibernate.hbm2ddl.auto">update</property>
  12.  
  13.         <!-- 注意注解的话，只能用class一个一个引用。除非与Spring整合才能扫描文件夹路径 -->
  14.         <mapping class="com.sunwii.mybatis.bean.User" />
  15.     </session-factory>
  16. </hibernate-configuration>

其它东西不需要，只需要在使用SqlSessionFactory（Mybatis）之前就构造SessionFactory（Hibernate）然后销毁它就可以了。

与Spring整合时：按照正常的Hibernate与Spring整合的方案就可以。

不与Spring整合时：Mybatis的工具类中添加新方法，用于自动构造DDL：

  1. package com.sunwii.mybatis.util;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  6. import org.apache.ibatis.io.Resources;
  7. import org.apache.ibatis.session.SqlSessionFactory;
  8. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  10. import com.sunwii.mybatis.constant.Constants;
  12. public class SessionFactoryUtil {
  13.     public static SqlSessionFactory creat(String configFile) {
  15.         SqlSessionFactory factory = null;
  16.         InputStream inputStream;
  17.         try {
  18.             inputStream = Resources.getResourceAsStream(configFile);
  19.             factory = new SqlSessionFactoryBuilder().build(inputStream);
  20.         } catch (IOException e) {
  21.             // TODO Auto-generated catch block
  22.             e.printStackTrace();
  23.         }
  24.         return factory;
  25.     }

  26.     //这里是新方法，通过判断标记决定是否要用于自动生成DDL
  27.     public static SqlSessionFactory creat(String configFile, boolean hibernateAutoDdl) {
  28.         if (hibernateAutoDdl) {
  29.             String hibernateConfigFile = Constants.Hibernate_LOCATION;
  30.             // 使用hibernate自动创建DDL
  31.             HibernateUtil.buildSessionFactory(hibernateConfigFile);
  32.         }
  34.         return creat(configFile);
  35.     }
  36. }

其中用到的Hibernate工具类为：

  1. package com.sunwii.mybatis.util;
  3. import java.util.Properties;
  5. import org.hibernate.SessionFactory;
  6. import org.hibernate.cfg.Configuration;
  8. import com.sunwii.mybatis.constant.Constants;
  10. public class HibernateUtil {
  11.     public static void buildSessionFactory(String hibernateConfigFile) {
  12.         String jdbcPropertiesLocation = Constants.JDBC_LOCATION;
  13.         Properties jdbcProperties = PropertiesUtil.loadFromClassPath(jdbcPropertiesLocation);
  15.         Properties hibernateJdbcProperties = new Properties();
  16.         hibernateJdbcProperties.setProperty("hibernate.connection.driver_class", jdbcProperties.getProperty("driver"));
  17.         hibernateJdbcProperties.setProperty("hibernate.connection.url", jdbcProperties.getProperty("url"));
  18.         hibernateJdbcProperties.setProperty("hibernate.connection.username", jdbcProperties.getProperty("user"));
  19.         hibernateJdbcProperties.setProperty("hibernate.connection.password", jdbcProperties.getProperty("password"));
  21.         final Configuration cfg = new Configuration();
  22.         cfg.addProperties(hibernateJdbcProperties);
  23.         cfg.configure(hibernateConfigFile);
  24.         SessionFactory sessionFactory = cfg.buildSessionFactory();
  26.         // 启动后销毁
  27.         sessionFactory.close();
  28.         sessionFactory = null;
  30.     }
  32. }

PropertiesUtil工具类：

  1. package com.sunwii.mybatis.util;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.util.Properties;
  7. public class PropertiesUtil {
  8.     public static Properties loadFromClassPath(String fileName) {
  9.         Properties props = new Properties();
  10.         while(fileName!=null && fileName.length()>0 && (fileName.startsWith("/") || fileName.startsWith("\\"))) {
  11.             fileName = fileName.substring(1);
  12.         }
  13.         InputStream is = Class.class.getResourceAsStream("/"+fileName);
  14.         try {
  15.             props.load(is);
  16.         } catch (IOException e) {
  17.             // TODO Auto-generated catch block
  18.             e.printStackTrace();
  19.         }
  20.         return props;
  21.     }
  22. }

常量配置类Constant:

  1. package com.sunwii.mybatis.constant;
  3. public class Constants {
  4.     public static String JDBC_LOCATION = "jdbc.properties";
  5.     public static String Hibernate_LOCATION = "hibernate.cfg.xml";
  6. }

示例的实体类User：

  1. @Entity
  2. @Table(name = "t_user")
  3. @Data
  4. @NoArgsConstructor
  5. @ToString
  6. public class User implements Serializable {
  7.     private static final long serialVersionUID = -4013951528313410972L;
  9.     @Id
  10.     @GeneratedValue(strategy = GenerationType.IDENTITY)
  11.     @Column(name = "id")
  12.     private Integer id;
  14.     @Column(length = 30)
  15.     private String name;
  17.     @Column
  18.     private Float height;
  20.     @Column
  21.     private Double salary;
  23.     @Column
  24.     private Integer vip;
  26.     @Column
  27.     @Temporal(TemporalType.DATE)
  28.     private Date birthday;
  30.     @Column
  31.     @Temporal(TemporalType.TIMESTAMP)
  32.     private Date lastlogin;
  34.     @Column
  35.     @Enumerated(EnumType.STRING)
  36.     // mybatis 默认会将枚举转化为字符串类型存储,此时数据库为varchar型
  37.     private State state;
  38.     
  39.     @Column
  40.     @Enumerated(EnumType.ORDINAL)
  41.     // 可以为mybatis设置枚举类型存储为其索引值存储，此时数据库为int型
  42.     private Level level;
  44.     @Column(length = 10)
  45.     @Enumerated(EnumType.ORDINAL)
  46.     // mybatis 自定义类型转换器将枚举转化为相应数字类型存储，此时数据库为int型
  47.     private Sex sex;
  48.     
  49.     @Column
  50.     @Type(type = "string")
  51.     // mybatis 自定义类型转换器将列表转化为相应字符串类型存储，此时数据库为varchar型
  52.     private List<String> tels;
  53.     
  55.     public User(int id) {
  56.         super();
  57.         this.id = id;
  58.     }
  60.     public User(int id, String name) {
  61.         super();
  62.         this.id = id;
  63.         this.name = name;
  64.     }
  66.     public User(String name) {
  67.         super();
  68.         this.name = name;
  69.     }
  70. }

注意：以上实体类用于Lombok插件，

  1. @Data
  2. @NoArgsConstructor
  3. @ToString
    三个注解属于Lombok插件注解，分别指示生成SETTER/GETTER、生成无参构造器、生成ToString
    其它注解都属于Hibernate（JPA规范）的注解，生成DDL就靠它们了。

Mybatis配置文件：

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE configuration
  3. PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  4. "http://mybatis.org/dtd/mybatis-3-config.dtd">
  5. <configuration>
  6.     <!-- 别名 -->
  7.     <typeAliases>
  8.         <!-- 指定包下所有别名为类名的简名 -->
  9.         <package name="com.sunwii.mybatis.bean" />
  10.     </typeAliases>
  11.  
  12.     <!-- 类型处理器 -->
  13.     <typeHandlers>
  14.         <!-- 改变默认处理枚举(枚举转换为int) -->
  15.         <typeHandler
  16.             handler="org.apache.ibatis.type.EnumOrdinalTypeHandler"
  17.             javaType="com.sunwii.mybatis.enums.Level" />
  18.  
  19.         <!-- 自定义处理枚举(枚举转换为枚举键值对的数字值) -->
  20.         <typeHandler
  21.             handler="com.sunwii.mybatis.typehandle.SexEnumTypeHandler"
  22.             javaType="com.sunwii.mybatis.enums.Sex" />
  23.  
  24.         <!-- 自定义处理列表(列表转换为字符串连接) -->
  25.         <!-- 注意，由于是非内置的转换类型，所以仅对select有效,insert/update/delete需要另行指定 -->
  26.         <!-- 另行指定示例：${tels,typeHandler=com.sunwii.mybatis.typehandle.ListTypeHandler} -->
  27.         <typeHandler
  28.             handler="com.sunwii.mybatis.typehandle.ListTypeHandler"
  29.             javaType="java.util.List" />
  30.     </typeHandlers>
  31.  
  32.  
  33.     <environments default="development">
  34.         <environment id="development">
  35.             <transactionManager type="JDBC" />
  36.             <!-- 自定义MyPoolDataSourceFactory简化配置 -->
  37.             <dataSource type="com.sunwii.mybatis.pool.MyPoolDataSourceFactory" />
  38.         </environment>
  39.     </environments>
  40.  
  41.     <mappers>
  42.         <package name="com/sunwii/mybatis/mapper" />
  43.     </mappers>
  44. </configuration>

连接池装饰类（用于简化Mybatis配置并统一jdbc配置文件路径常量）：

  1. package com.sunwii.mybatis.pool;
  3. import java.util.Properties;
  5. import org.apache.ibatis.datasource.pooled.PooledDataSource;
  6. import org.apache.ibatis.datasource.pooled.PooledDataSourceFactory;
  8. import com.sunwii.mybatis.constant.Constants;
  9. import com.sunwii.mybatis.util.PropertiesUtil;
  11. public class MyPoolDataSourceFactory extends PooledDataSourceFactory {
  12.     public MyPoolDataSourceFactory() {
  13.         PooledDataSource dataSource = new PooledDataSource();
  15.         // 更多属性可以通过<property>来设置。  
  16.         String jdbcPropertiesFile = Constants.JDBC_LOCATION;
  17.         Properties prop = PropertiesUtil.loadFromClassPath(jdbcPropertiesFile);
  19.         dataSource.setDriver(prop.getProperty("driver"));
  20.         dataSource.setUrl(prop.getProperty("url"));
  21.         dataSource.setUsername(prop.getProperty("user"));
  22.         dataSource.setPassword(prop.getProperty("password")); 
  23.         this.dataSource = dataSource;
  24.     }
  26. }

用到的几个枚举类：

  1. package com.sunwii.mybatis.enums;
  3. public enum Level {
  4.     LEVEL_0, 
  5.     LEVEL_1, 
  6.     LEVEL_2, 
  7.     LEVEL_3, 
  8.     LEVEL_4, 
  9.     LEVEL_5
  10. }
  13. package com.sunwii.mybatis.enums;
  15. import java.util.HashMap;
  17. public enum Sex {
  18.     MAN("男", 0), WOMAN("女", 1);
  20.     private String key;
  21.     public String getKey() {
  22.         return key;
  23.     }
  25.     public void setKey(String key) {
  26.         this.key = key;
  27.     }
  29.     public Integer getValue() {
  30.         return value;
  31.     }
  33.     public void setValue(Integer value) {
  34.         this.value = value;
  35.     }
  37.     private Integer value;
  39.     private static HashMap<Integer, Sex> valueMap = new HashMap<Integer, Sex>();
  40.     private static HashMap<String, Sex> keyMap = new HashMap<String, Sex>();
  42.     static {
  43.         for (Sex item : Sex.values()) {
  44.             valueMap.put(item.value, item);
  45.             keyMap.put(item.key, item);
  46.         }
  47.     }
  49.     Sex(String key, Integer value) {
  50.         this.key = key;
  51.         this.value = value;
  52.     }
  54.     public static Sex getByValue(int value) {
  55.         Sex result = valueMap.get(value);
  56.         return result;
  57.     }
  59.     public static Sex getByKey(String key) {
  60.         Sex result = keyMap.get(key);
  61.         return result;
  62.     }
  63. }
  66. package com.sunwii.mybatis.enums;
  68. public enum State {
  69.     OK, ERROR, UNKNOWN
  70. }

用到的类型转换器：

  1. package com.sunwii.mybatis.typehandle;
  3. import java.sql.CallableStatement;
  4. import java.sql.PreparedStatement;
  5. import java.sql.ResultSet;
  6. import java.sql.SQLException;
  8. import org.apache.ibatis.type.JdbcType;
  9. import org.apache.ibatis.type.TypeHandler;
  11. import com.sunwii.mybatis.enums.Sex;
  13. /**
  14.  * -必须实现所有方法，不然的话查询有可能查询到为null
  15.  * @author Administrator
  16.  *
  17.  */
  18. public class SexEnumTypeHandler implements TypeHandler<Sex> {
  20.     /**
  21.      * 转换到数据库的值
  22.      */
  23.     @Override
  24.     public void setParameter(PreparedStatement ps, int i, Sex parameter, JdbcType jdbcType) throws SQLException {
  25.         ps.setInt(i, parameter.getValue());
  26.     }
  28.     /**
  29.      * 从数据库转换得到
  30.      */
  31.     @Override
  32.     public Sex getResult(ResultSet rs, String columnName) throws SQLException {
  33.         return Sex.getByValue(rs.getInt(columnName));
  34.     }
  36.     /**
  37.      * 从数据库转换得到
  38.      */
  39.     @Override
  40.     public Sex getResult(ResultSet rs, int columnIndex) throws SQLException {
  41.         return Sex.getByValue(rs.getInt(columnIndex));
  42.     }
  44.     /**
  45.      * 从数据库转换得到
  46.      */
  47.     @Override
  48.     public Sex getResult(CallableStatement cs, int columnIndex) throws SQLException {
  49.         return Sex.getByValue(cs.getInt(columnIndex));
  50.     }
  52. }
  1. package com.sunwii.mybatis.typehandle;
  3. import java.sql.CallableStatement;
  4. import java.sql.PreparedStatement;
  5. import java.sql.ResultSet;
  6. import java.sql.SQLException;
  7. import java.util.Arrays;
  8. import java.util.List;
  10. import org.apache.ibatis.type.JdbcType;
  11. import org.apache.ibatis.type.TypeHandler;
  13. import com.sunwii.mybatis.util.ArrayUtil;
  15. /**
  16.  * -必须实现所有方法，不然的话查询有可能查询到为null
  17.  * @author Administrator
  18.  *
  19.  */
  20. public class ListTypeHandler implements TypeHandler<List<?>> {
  22.     @SuppressWarnings({ "unchecked", "rawtypes" })
  23.     @Override
  24.     public void setParameter(PreparedStatement ps, int i, List parameter, JdbcType jdbcType) throws SQLException {
  25.         String[] strArr = ArrayUtil.fromList((List<String>) parameter);
  26.         String strs = ArrayUtil.asString(",", strArr);
  27.         ps.setString(i, strs);
  28.     }
  30.     @Override
  31.     public List<String> getResult(ResultSet rs, String columnName) throws SQLException {
  32.         List<String> list = null;
  33.         String strs = rs.getString(columnName);
  34.         if (strs != null && strs.length() > 0) {
  35.             list = Arrays.asList(strs.split(","));
  36.         }
  37.         return list;
  38.     }
  40.     @Override
  41.     public List<String> getResult(ResultSet rs, int columnIndex) throws SQLException {
  42.         List<String> list = null;
  43.         String strs = rs.getString(columnIndex);
  44.         if (strs != null && strs.length() > 0) {
  45.             list = Arrays.asList(strs.split(","));
  46.         }
  47.         return list;
  48.     }
  50.     @Override
  51.     public List<String> getResult(CallableStatement cs, int columnIndex) throws SQLException {
  52.         List<String> list = null;
  53.         String strs = cs.getString(columnIndex);
  54.         if (strs != null && strs.length() > 0) {
  55.             list = Arrays.asList(strs.split(","));
  56.         }
  57.         return list;
  58.     }
  60. }

用到的数组集合转换工具类：

  1. package com.sunwii.mybatis.util;
  3. import java.lang.reflect.Array;
  4. import java.util.ArrayList;
  5. import java.util.Arrays;
  6. import java.util.Collection;
  7. import java.util.HashMap;
  8. import java.util.HashSet;
  9. import java.util.List;
  10. import java.util.Map;
  11. import java.util.Set;
  13. public class ArrayUtil {
  14.     @SuppressWarnings("unchecked")
  15.     public static <T> List<T> asList(T... args) {
  16.         return Arrays.asList(args);
  17.     }
  19.     public static <T> List<T> asListFromSet(Set<T> set) {
  20.         if (set == null || set.size() < 1) {
  21.             return null;
  22.         }
  23.         List<T> list = new ArrayList<T>();
  24.         for (T t : set) {
  25.             list.add(t);
  26.         }
  28.         return list;
  29.     }
  31.     public static <T> List<T> asListFromArray(T[] array) {
  32.         if (array == null || array.length < 1) {
  33.             return null;
  34.         }
  35.         List<T> list = new ArrayList<T>();
  36.         for (T t : array) {
  37.             list.add(t);
  38.         }
  40.         return list;
  41.     }
  43.     public static <T> List<T> asListFromMapKey(Map<T, ?> map) {
  44.         if (map == null || map.size() < 1) {
  45.             return null;
  46.         }
  48.         return ArrayUtil.asListFromSet(map.keySet());
  49.     }
  51.     public static <T> List<T> asListFromMapValue(Map<?, T> map) {
  52.         if (map == null || map.size() < 1) {
  53.             return null;
  54.         }
  56.         List<T> list = new ArrayList<T>();
  57.         Collection<T> values = map.values();
  58.         for (T t : values) {
  59.             list.add(t);
  60.         }
  61.         return list;
  62.     }
  64.     @SuppressWarnings("unchecked")
  65.     public static <T> T[] fromArray(T... args) {
  66.         if (args == null || args.length < 1) {
  67.             return null;
  68.         }
  70.         T[] array = (T[]) Array.newInstance(args[0].getClass(), args.length);
  72.         for (int i = 0; i < args.length; i++) {
  73.             array[i] = args[i];
  74.         }
  76.         return array;
  77.     }
  79.     @SuppressWarnings("unchecked")
  80.     public static <T> T[] fromList(List<T> list) {
  81.         if (list == null || list.size() < 1) {
  82.             return null;
  83.         }
  85.         Class<T> clz = null;
  86.         for (T t : list) {
  87.             clz = (Class<T>) t.getClass();
  88.             break;
  89.         }
  91.         T[] array = (T[]) Array.newInstance(clz, list.size());
  93.         int i = 0;
  94.         for (T t : list) {
  95.             array[i] = t;
  96.             i++;
  97.         }
  99.         return array;
  100.     }
  102.     @SuppressWarnings("unchecked")
  103.     public static <T> T[] fromSet(Set<T> set) {
  104.         if (set == null || set.size() < 1) {
  105.             return null;
  106.         }
  108.         Class<T> clz = null;
  109.         for (T t : set) {
  110.             clz = (Class<T>) t.getClass();
  111.             break;
  112.         }
  114.         T[] array = (T[]) Array.newInstance(clz, set.size());
  116.         int i = 0;
  117.         for (T t : set) {
  118.             array[i] = t;
  119.             i++;
  120.         }
  122.         return array;
  123.     }
  125.     public static <T> T[] fromMapKey(Map<T, ?> map) {
  126.         if (map == null || map.size() < 1) {
  127.             return null;
  128.         }
  130.         Set<T> set = map.keySet();
  132.         return ArrayUtil.fromSet(set);
  133.     }
  135.     public static <T> T[] fromMapValue(Map<?, T> map) {
  136.         if (map == null || map.size() < 1) {
  137.             return null;
  138.         }
  140.         List<T> list = new ArrayList<T>();
  141.         Collection<T> values = map.values();
  142.         for (T t : values) {
  143.             list.add(t);
  144.         }
  145.         return ArrayUtil.fromList(list);
  146.     }
  148.     @SuppressWarnings("unchecked")
  149.     public static <T> Set<T> asSet(T... args) {
  150.         if (args == null || args.length < 1) {
  151.             return null;
  152.         }
  153.         Set<T> set = new HashSet<T>();
  154.         for (int i = 0; i < args.length; i++) {
  155.             if (!set.contains(args[i])) {
  156.                 set.add(args[i]);
  157.             }
  158.         }
  160.         return set;
  161.     }
  163.     public static <T> Set<T> asSetFromArray(T[] array) {
  164.         if (array == null || array.length < 1) {
  165.             return null;
  166.         }
  167.         Set<T> set = new HashSet<T>();
  168.         for (T t : array) {
  169.             set.add(t);
  170.         }
  172.         return set;
  173.     }
  175.     public static <T> Set<T> asSetFromMapKey(Map<T, ?> map) {
  176.         if (map == null || map.size() < 1) {
  177.             return null;
  178.         }
  180.         return map.keySet();
  181.     }
  183.     public static <T> Set<T> asSetFromMapValue(Map<?, T> map) {
  184.         if (map == null || map.size() < 1) {
  185.             return null;
  186.         }
  188.         Set<T> set = new HashSet<T>();
  189.         Collection<T> values = map.values();
  190.         for (T t : values) {
  191.             set.add(t);
  192.         }
  193.         return set;
  194.     }
  196.     public static <T1, T2> Map<T1, T2> asMapFrom(Set<T1> keySet, Set<T2> valueSet) {
  197.         if (keySet == null || keySet.size() < 1 || valueSet == null || valueSet.size() < 1) {
  198.             return null;
  199.         }
  201.         Map<T1, T2> map = new HashMap<T1, T2>();
  202.         List<T2> list = ArrayUtil.asListFromSet(valueSet);
  203.         int i = 0;
  204.         for (T1 t : keySet) {
  205.             try {
  206.                 map.put(t, list.get(i++));
  207.             } catch (Exception e) {// 超长
  208.                 map.put(t, null);
  209.             }
  210.         }
  212.         return map;
  213.     }
  215.     @SuppressWarnings("unchecked")
  216.     public static <T> String asString(String separator, T... args) {
  217.         if (args == null || args.length < 1) {
  218.             return null;
  219.         }
  220.         StringBuilder sp = new StringBuilder();
  221.         for (int i = 0; i < args.length; i++) {
  223.             sp.append(args[i]);
  224.             if (i != args.length - 1) {
  225.                 sp.append(separator);
  226.             }
  227.         }
  229.         return sp.toString();
  230.     }
  231. }

映射文件：UserMapper.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3. PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5. <mapper namespace="com.sunwii.mybatis.mapper.UserMapper">
  6.     <select id="selectById" parameterType="Integer"
  7.         resultType="User">
  8.         select * from t_user where id = #{id}
  9.     </select>
  10.  
  11.     <select id="selectByName" parameterType="String"
  12.         resultType="User">
  13.         select * from t_user where name like "%"#{name}"%"
  14.     </select>
  15.  
  16.     <insert id="insert">
  17.         insert into
  18.         t_user(
  19.         name, birthday, vip, salary, height, lastlogin,level,state,sex,tels
  20.         )values(
  21.         #{name},
  22.         #{birthday},
  23.         #{vip},
  24.         #{salary},
  25.         #{height},
  26.         #{lastlogin},
  27.         #{level},
  28.         #{state},
  29.         #{sex},
  30.         #{tels,typeHandler=com.sunwii.mybatis.typehandle.ListTypeHandler}
  31.         )
  32.     </insert>
  33.  
  34.     <update id="update">
  35.         update t_user set
  36.         name=#{name},
  37.         birthday=#{birthday},
  38.         vip=#{vip},
  39.         salary=#{salary},
  40.         height=#{height},
  41.         lastlogin=#{lastlogin},
  42.         level=#{level},
  43.         state=#{state},
  44.         sex=#{sex},
  45.         tels=#{tels,typeHandler=com.sunwii.mybatis.typehandle.ListTypeHandler}
  46.         where id=#{id}
  47.     </update>
  48.  
  49.     <delete id="delete" parameterType="Integer">
  50.         delete from t_user where
  51.         id=#{id}
  52.     </delete>
  53. </mapper>

测试示例：

  1. package com.sunwii.mybatis.test.mapper;
  3. import java.util.Arrays;
  4. import java.util.List;
  6. import org.apache.commons.logging.Log;
  7. import org.apache.commons.logging.LogFactory;
  8. import org.apache.ibatis.session.SqlSession;
  9. import org.apache.ibatis.session.SqlSessionFactory;
  10. import org.junit.Test;
  12. import com.sunwii.mybatis.bean.User;
  13. import com.sunwii.mybatis.enums.Level;
  14. import com.sunwii.mybatis.enums.Sex;
  15. import com.sunwii.mybatis.enums.State;
  16. import com.sunwii.mybatis.mapper.UserMapper;
  17. import com.sunwii.mybatis.test.insert.TestInsert;
  18. import com.sunwii.mybatis.util.CurrentUtil;
  19. import com.sunwii.mybatis.util.SessionFactoryUtil;
  21. public class testMapper {
  22.     private static Log log = LogFactory.getLog(TestInsert.class);
  23.     private static SqlSessionFactory sf = SessionFactoryUtil.creat("mybatis-config.xml", true);
  25.     @Test
  26.     public void testMapperInsert() {
  27.         User user = new User();
  28.         //user.setId(50);
  29.         user.setName("sunwii");
  30.         user.setVip(1);
  31.         user.setSalary(3333.00);
  32.         user.setHeight(1.70f);
  33.         user.setBirthday(CurrentUtil.currentDate());
  34.         user.setLastlogin(CurrentUtil.currentTimestamp());
  35.         user.setLevel(Level.LEVEL_3);
  36.         user.setState(State.OK);
  37.         user.setSex(Sex.WOMAN);
  38.         user.setTels(Arrays.asList("133xxxxxxx", "159xxxxxxxx"));
  40.         int rs = 0;
  41.         SqlSession session = sf.openSession();
  42.         UserMapper userMapper = session.getMapper(UserMapper.class);
  43.         try {
  44.             rs = userMapper.insert(user);
  45.             session.commit();
  46.         } catch (Exception e) {
  47.             rs = 0;
  48.             session.rollback();
  49.             e.printStackTrace();
  50.         } finally {
  51.             session.close();
  52.         }
  54.         log.info("操作结果：" + rs);
  56.     }
  58.     @Test
  59.     public void testMapperUpdate() {
  60.         User user = new User();
  61.         user.setId(1);
  62.         user.setName("sunwii--55550");
  63.         user.setVip(1);
  64.         user.setSalary(3333.00);
  65.         user.setHeight(1.70f);
  66.         user.setBirthday(CurrentUtil.currentDate());
  67.         user.setLastlogin(CurrentUtil.currentTimestamp());
  68.         user.setLevel(Level.LEVEL_2);
  69.         user.setState(State.ERROR);
  70.         user.setSex(Sex.MAN);
  71.         user.setTels(Arrays.asList("136xxxxxx", "139xxxxxxx"));
  73.         int rs = 0;
  74.         SqlSession session = sf.openSession();
  75.         UserMapper userMapper = session.getMapper(UserMapper.class);
  76.         try {
  77.             rs = userMapper.update(user);
  78.             session.commit();
  79.         } catch (Exception e) {
  80.             rs = 0;
  81.             session.rollback();
  82.             e.printStackTrace();
  83.         } finally {
  84.             session.close();
  85.         }
  87.         log.info("操作结果：" + rs);
  89.     }
  91.     @Test
  92.     public void testMapperDelete() {
  93.         User user = new User(50);
  95.         int rs = 0;
  96.         SqlSession session = sf.openSession();
  97.         UserMapper userMapper = session.getMapper(UserMapper.class);
  98.         try {
  99.             rs = userMapper.delete(user.getId());
  100.             session.commit();
  101.         } catch (Exception e) {
  102.             rs = 0;
  103.             session.rollback();
  104.             e.printStackTrace();
  105.         } finally {
  106.             session.close();
  107.         }
  109.         log.info("操作结果：" + rs);
  111.     }
  113.     @Test
  114.     public void testMapperGetOne() {
  115.         Integer id = 50;
  116.         User user = null;
  117.         SqlSession session = sf.openSession();
  118.         UserMapper userMapper = session.getMapper(UserMapper.class);
  119.         user = userMapper.selectById(id);
  121.         log.info(user);
  123.     }
  125.     @Test
  126.     public void testMapperGetList() {
  127.         String userName = "sunwii";
  129.         List<User> users = null;
  130.         SqlSession session = sf.openSession();
  131.         UserMapper userMapper = session.getMapper(UserMapper.class);
  132.         users = userMapper.selectByName(userName);
  134.         for (User user : users) {
  135.             log.info(user);
  136.         }
  138.     }
  139. }

<<Mybatis总结之如何自动生成数据库表结构>>

说明： 

    这里多余的步骤仅仅是为了存档下代码（以及方便一些初学者不看代码不知道怎么回事的原因:里边涉及了各种常用类型的转换和映射）。

    本文中最重要的就是Hibernate的几个包的选取，以及配置文件的精简，还有就是加载Hibernate的SessionFactory的方法。

    这些说来说去都是Hibernate的东西。跟Mybatis原本是没有一点关系的。只不过需要用于，那纯属相当于复习一下Hibernate了。

原文链接：http://www.cnblogs.com/dreamyoung/p/11776426.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Spring Boot热门文章

  • 史上最详 Thymeleaf 使用教程
  • Spring Boot如何通过java -jar启动
  • Spring Boot 2.x（六）：优雅的统一返回值
  • Springboot使用Logback实现日志配置与异常记录
  • 使用SpringBoot+EasyExcel+Vue实现excel表格的导入和导出详解
  • spring boot上传文件超出大小异常无法捕获问题
  • paging组件的用法和意义
  • springboot2.0集成rabbitmq的示例代码
  • Spring MVC学习step1——框架熟悉
  • spring boot ${}占位符不起作用的解决方案

    • Spring Boot推荐文章

  • 3分钟带你搞定Spring Boot中Schedule
  • 不单独部署注册中心，又要具备注册中心的功能，我能上天！
  • 从零开始学Spring Boot系列-集成Spring Security实现用户认证与授权
  • 不单独部署注册中心，又要具备注册中心的功能，咋不让我上天？
  • EasyExcel 无法读取图片？用poi写了一个工具类
  • 【进阶篇】使用 Stream 流对比两个集合的常用操作分享
  • 关于DDD和COLA的一些总结和思考
  • SnakeYaml反序列化分析
  • RestTemplate进行https请求时适配信任证书
  • Kryo反序列化链分析

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号