Mybatis总结之如何自动生成数据库表结构
一般情况下，用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文件：（去掉多余的，精简后的内容）
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!--不采用InnoDB方式加快速度 -->
<property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property> <!-- 注意update方式时对于属性的删减并不会删除数据库字段 -->
<property name="hibernate.hbm2ddl.auto">update</property> <!-- 注意注解的话，只能用class一个一个引用。除非与Spring整合才能扫描文件夹路径 -->
<mapping class="com.sunwii.mybatis.bean.User" />
</session-factory>
</hibernate-configuration>
注解的实体类：
@Entity
@Table(name = "t_user")
@Data
@NoArgsConstructor
@ToString
public class User implements Serializable {
private static final long serialVersionUID = -4013951528313410972L; @Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Integer id; @Column(length = 30)
private String name; @Column
private Float height; @Column
private Double salary; @Column
private Integer vip; @Column
@Temporal(TemporalType.DATE)
private Date birthday; @Column
@Temporal(TemporalType.TIMESTAMP)
private Date lastlogin; @Column
@Enumerated(EnumType.STRING)
// mybatis 默认会将枚举转化为字符串类型存储,此时数据库为varchar型
private State state; @Column
@Enumerated(EnumType.ORDINAL)
// 可以为mybatis设置枚举类型存储为其索引值存储，此时数据库为int型
private Level level; @Column(length = 10)
@Enumerated(EnumType.ORDINAL)
// mybatis 自定义类型转换器将枚举转化为相应数字类型存储，此时数据库为int型
private Sex sex; @Column
@Type(type = "string")
// mybatis 自定义类型转换器将列表转化为相应字符串类型存储，此时数据库为varchar型
private List<String> tels; public User(int id) {
super();
this.id = id;
} public User(int id, String name) {
super();
this.id = id;
this.name = name;
} public User(String name) {
super();
this.name = name;
}
}
注意：以上实体类用了Lombok插件来减少代码量（只要是为了不写setter/getter、toString等。Lombok插件的使用请参考其它地方。）
@Data
@NoArgsConstructor
@ToString
三个注解属于Lombok插件注解，分别指示生成SETTER/GETTER、生成无参构造器、生成ToString 其它注解都属于Hibernate（JPA规范）的注解，生成DDL就靠它们了。 注解-说明：
@Entity
@Table(name = "t_user")
这里指实体类对应了t_user表 @Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
这里指表主健自动增长 @Column
这里指表字段名称与属性同名,它可以另外指定长度，名称。
@Temporal(TemporalType.DATE)
这里指表字段采用Date类型存储
@Enumerated(EnumType.STRING)
这里指表字段采用varchar类型来存储枚举属性 这个简短示例仅列出简单的类型的注解，并不涉及表关联之间的注解，幸好的是，注解并不多，更多注解可以参考Hibernate(JPA)注解相关内容。
至此，只需要在使用SqlSessionFactory（Mybatis）之前就构造SessionFactory（Hibernate）然后销毁它就可以了。至于如何初始化Hibernate的SessionFactory，应该都知道。如下：
Mybatis与Spring整合时：简单地配置一个hibernate的SessionFactory相关的BEAN了事。这里不谈。
Mybatis不与Spring整合时：
Mybatis的工具类中添加新方法，用于自动构造DDL：
package com.sunwii.mybatis.util; import java.io.IOException;
import java.io.InputStream; import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder; import com.sunwii.mybatis.constant.Constants; public class SessionFactoryUtil {
public static SqlSessionFactory creat(String configFile) { SqlSessionFactory factory = null;
InputStream inputStream;
try {
inputStream = Resources.getResourceAsStream(configFile);
factory = new SqlSessionFactoryBuilder().build(inputStream);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return factory;
}
//这里是新方法，通过判断标记决定是否要用于自动生成DDL
public static SqlSessionFactory creat(String configFile, boolean hibernateAutoDdl) {
if (hibernateAutoDdl) {
String hibernateConfigFile = Constants.Hibernate_LOCATION;
// 使用hibernate自动创建DDL
HibernateUtil.buildSessionFactory(hibernateConfigFile);
} return creat(configFile);
}
}
其中用到的Hibernate工具类为：
package com.sunwii.mybatis.util; import java.util.Properties; import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration; import com.sunwii.mybatis.constant.Constants; public class HibernateUtil {
public static void buildSessionFactory(String hibernateConfigFile) {
String jdbcPropertiesLocation = Constants.JDBC_LOCATION;
Properties jdbcProperties = PropertiesUtil.loadFromClassPath(jdbcPropertiesLocation); Properties hibernateJdbcProperties = new Properties();
hibernateJdbcProperties.setProperty("hibernate.connection.driver_class", jdbcProperties.getProperty("driver"));
hibernateJdbcProperties.setProperty("hibernate.connection.url", jdbcProperties.getProperty("url"));
hibernateJdbcProperties.setProperty("hibernate.connection.username", jdbcProperties.getProperty("user"));
hibernateJdbcProperties.setProperty("hibernate.connection.password", jdbcProperties.getProperty("password")); final Configuration cfg = new Configuration();
cfg.addProperties(hibernateJdbcProperties);
cfg.configure(hibernateConfigFile);
SessionFactory sessionFactory = cfg.buildSessionFactory(); // 启动后销毁
sessionFactory.close();
sessionFactory = null; } }
PropertiesUtil工具类：
package com.sunwii.mybatis.util; import java.io.IOException;
import java.io.InputStream;
import java.util.Properties; public class PropertiesUtil {
public static Properties loadFromClassPath(String fileName) {
Properties props = new Properties();
while(fileName!=null && fileName.length()>0 && (fileName.startsWith("/") || fileName.startsWith("\\"))) {
fileName = fileName.substring(1);
}
InputStream is = Class.class.getResourceAsStream("/"+fileName);
try {
props.load(is);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return props;
}
}
常量配置类Constant:
package com.sunwii.mybatis.constant;
public class Constants {
public static String JDBC_LOCATION = "jdbc.properties";
public static String Hibernate_LOCATION = "hibernate.cfg.xml";
}
Mybatis配置文件：
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- 别名 -->
<typeAliases>
<!-- 指定包下所有别名为类名的简名 -->
<package name="com.sunwii.mybatis.bean" />
</typeAliases> <!-- 类型处理器 -->
<typeHandlers>
<!-- 改变默认处理枚举(枚举转换为int) -->
<typeHandler
handler="org.apache.ibatis.type.EnumOrdinalTypeHandler"
javaType="com.sunwii.mybatis.enums.Level" /> <!-- 自定义处理枚举(枚举转换为枚举键值对的数字值) -->
<typeHandler
handler="com.sunwii.mybatis.typehandle.SexEnumTypeHandler"
javaType="com.sunwii.mybatis.enums.Sex" /> <!-- 自定义处理列表(列表转换为字符串连接) -->
<!-- 注意，由于是非内置的转换类型，所以仅对select有效,insert/update/delete需要另行指定 -->
<!-- 另行指定示例：${tels,typeHandler=com.sunwii.mybatis.typehandle.ListTypeHandler} -->
<typeHandler
handler="com.sunwii.mybatis.typehandle.ListTypeHandler"
javaType="java.util.List" />
</typeHandlers> <environments default="development">
<environment id="development">
<transactionManager type="JDBC" />
<!-- 自定义MyPoolDataSourceFactory简化配置 -->
<dataSource type="com.sunwii.mybatis.pool.MyPoolDataSourceFactory" />
</environment>
</environments> <mappers>
<package name="com/sunwii/mybatis/mapper" />
</mappers>
</configuration>
连接池装饰类（用于简化Mybatis配置并统一jdbc配置文件路径常量）：
package com.sunwii.mybatis.pool; import java.util.Properties; import org.apache.ibatis.datasource.pooled.PooledDataSource;
import org.apache.ibatis.datasource.pooled.PooledDataSourceFactory; import com.sunwii.mybatis.constant.Constants;
import com.sunwii.mybatis.util.PropertiesUtil; public class MyPoolDataSourceFactory extends PooledDataSourceFactory {
public MyPoolDataSourceFactory() {
PooledDataSource dataSource = new PooledDataSource(); // 更多属性可以通过<property>来设置。
String jdbcPropertiesFile = Constants.JDBC_LOCATION;
Properties prop = PropertiesUtil.loadFromClassPath(jdbcPropertiesFile); dataSource.setDriver(prop.getProperty("driver"));
dataSource.setUrl(prop.getProperty("url"));
dataSource.setUsername(prop.getProperty("user"));
dataSource.setPassword(prop.getProperty("password"));
this.dataSource = dataSource;
} }
用到的几个枚举类：
package com.sunwii.mybatis.enums;
public enum Level {
LEVEL_0,
LEVEL_1,
LEVEL_2,
LEVEL_3,
LEVEL_4,
LEVEL_5
}
package com.sunwii.mybatis.enums;
import java.util.HashMap;
public enum Sex {
MAN("男", 0), WOMAN("女", 1);
private String key;
public String getKey() {
return key;
}
public void setKey(String key) {
this.key = key;
}
public Integer getValue() {
return value;
}
public void setValue(Integer value) {
this.value = value;
}
private Integer value;
private static HashMap<Integer, Sex> valueMap = new HashMap<Integer, Sex>();
private static HashMap<String, Sex> keyMap = new HashMap<String, Sex>();
static {
for (Sex item : Sex.values()) {
valueMap.put(item.value, item);
keyMap.put(item.key, item);
}
}
Sex(String key, Integer value) {
this.key = key;
this.value = value;
}
public static Sex getByValue(int value) {
Sex result = valueMap.get(value);
return result;
}
public static Sex getByKey(String key) {
Sex result = keyMap.get(key);
return result;
}
}
package com.sunwii.mybatis.enums;
public enum State {
OK, ERROR, UNKNOWN
}
用到的类型转换器：
package com.sunwii.mybatis.typehandle; import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException; import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.TypeHandler; import com.sunwii.mybatis.enums.Sex; /**
* -必须实现所有方法，不然的话查询有可能查询到为null
* @author Administrator
*
*/
public class SexEnumTypeHandler implements TypeHandler<Sex> { /**
* 转换到数据库的值
*/
@Override
public void setParameter(PreparedStatement ps, int i, Sex parameter, JdbcType jdbcType) throws SQLException {
ps.setInt(i, parameter.getValue());
} /**
* 从数据库转换得到
*/
@Override
public Sex getResult(ResultSet rs, String columnName) throws SQLException {
return Sex.getByValue(rs.getInt(columnName));
} /**
* 从数据库转换得到
*/
@Override
public Sex getResult(ResultSet rs, int columnIndex) throws SQLException {
return Sex.getByValue(rs.getInt(columnIndex));
} /**
* 从数据库转换得到
*/
@Override
public Sex getResult(CallableStatement cs, int columnIndex) throws SQLException {
return Sex.getByValue(cs.getInt(columnIndex));
} }
package com.sunwii.mybatis.typehandle; import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.List; import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.TypeHandler; import com.sunwii.mybatis.util.ArrayUtil; /**
* -必须实现所有方法，不然的话查询有可能查询到为null
* @author Administrator
*
*/
public class ListTypeHandler implements TypeHandler<List<?>> { @SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public void setParameter(PreparedStatement ps, int i, List parameter, JdbcType jdbcType) throws SQLException {
String[] strArr = ArrayUtil.fromList((List<String>) parameter);
String strs = ArrayUtil.asString(",", strArr);
ps.setString(i, strs);
} @Override
public List<String> getResult(ResultSet rs, String columnName) throws SQLException {
List<String> list = null;
String strs = rs.getString(columnName);
if (strs != null && strs.length() > 0) {
list = Arrays.asList(strs.split(","));
}
return list;
} @Override
public List<String> getResult(ResultSet rs, int columnIndex) throws SQLException {
List<String> list = null;
String strs = rs.getString(columnIndex);
if (strs != null && strs.length() > 0) {
list = Arrays.asList(strs.split(","));
}
return list;
} @Override
public List<String> getResult(CallableStatement cs, int columnIndex) throws SQLException {
List<String> list = null;
String strs = cs.getString(columnIndex);
if (strs != null && strs.length() > 0) {
list = Arrays.asList(strs.split(","));
}
return list;
} }
用到的数组集合转换工具类：
package com.sunwii.mybatis.util; import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set; public class ArrayUtil {
@SuppressWarnings("unchecked")
public static <T> List<T> asList(T... args) {
return Arrays.asList(args);
} public static <T> List<T> asListFromSet(Set<T> set) {
if (set == null || set.size() < 1) {
return null;
}
List<T> list = new ArrayList<T>();
for (T t : set) {
list.add(t);
} return list;
} public static <T> List<T> asListFromArray(T[] array) {
if (array == null || array.length < 1) {
return null;
}
List<T> list = new ArrayList<T>();
for (T t : array) {
list.add(t);
} return list;
} public static <T> List<T> asListFromMapKey(Map<T, ?> map) {
if (map == null || map.size() < 1) {
return null;
} return ArrayUtil.asListFromSet(map.keySet());
} public static <T> List<T> asListFromMapValue(Map<?, T> map) {
if (map == null || map.size() < 1) {
return null;
} List<T> list = new ArrayList<T>();
Collection<T> values = map.values();
for (T t : values) {
list.add(t);
}
return list;
} @SuppressWarnings("unchecked")
public static <T> T[] fromArray(T... args) {
if (args == null || args.length < 1) {
return null;
} T[] array = (T[]) Array.newInstance(args[0].getClass(), args.length); for (int i = 0; i < args.length; i++) {
array[i] = args[i];
} return array;
} @SuppressWarnings("unchecked")
public static <T> T[] fromList(List<T> list) {
if (list == null || list.size() < 1) {
return null;
} Class<T> clz = null;
for (T t : list) {
clz = (Class<T>) t.getClass();
break;
} T[] array = (T[]) Array.newInstance(clz, list.size()); int i = 0;
for (T t : list) {
array[i] = t;
i++;
} return array;
} @SuppressWarnings("unchecked")
public static <T> T[] fromSet(Set<T> set) {
if (set == null || set.size() < 1) {
return null;
} Class<T> clz = null;
for (T t : set) {
clz = (Class<T>) t.getClass();
break;
} T[] array = (T[]) Array.newInstance(clz, set.size()); int i = 0;
for (T t : set) {
array[i] = t;
i++;
} return array;
} public static <T> T[] fromMapKey(Map<T, ?> map) {
if (map == null || map.size() < 1) {
return null;
} Set<T> set = map.keySet(); return ArrayUtil.fromSet(set);
} public static <T> T[] fromMapValue(Map<?, T> map) {
if (map == null || map.size() < 1) {
return null;
} List<T> list = new ArrayList<T>();
Collection<T> values = map.values();
for (T t : values) {
list.add(t);
}
return ArrayUtil.fromList(list);
} @SuppressWarnings("unchecked")
public static <T> Set<T> asSet(T... args) {
if (args == null || args.length < 1) {
return null;
}
Set<T> set = new HashSet<T>();
for (int i = 0; i < args.length; i++) {
if (!set.contains(args[i])) {
set.add(args[i]);
}
} return set;
} public static <T> Set<T> asSetFromArray(T[] array) {
if (array == null || array.length < 1) {
return null;
}
Set<T> set = new HashSet<T>();
for (T t : array) {
set.add(t);
} return set;
} public static <T> Set<T> asSetFromMapKey(Map<T, ?> map) {
if (map == null || map.size() < 1) {
return null;
} return map.keySet();
} public static <T> Set<T> asSetFromMapValue(Map<?, T> map) {
if (map == null || map.size() < 1) {
return null;
} Set<T> set = new HashSet<T>();
Collection<T> values = map.values();
for (T t : values) {
set.add(t);
}
return set;
} public static <T1, T2> Map<T1, T2> asMapFrom(Set<T1> keySet, Set<T2> valueSet) {
if (keySet == null || keySet.size() < 1 || valueSet == null || valueSet.size() < 1) {
return null;
} Map<T1, T2> map = new HashMap<T1, T2>();
List<T2> list = ArrayUtil.asListFromSet(valueSet);
int i = 0;
for (T1 t : keySet) {
try {
map.put(t, list.get(i++));
} catch (Exception e) {// 超长
map.put(t, null);
}
} return map;
} @SuppressWarnings("unchecked")
public static <T> String asString(String separator, T... args) {
if (args == null || args.length < 1) {
return null;
}
StringBuilder sp = new StringBuilder();
for (int i = 0; i < args.length; i++) { sp.append(args[i]);
if (i != args.length - 1) {
sp.append(separator);
}
} return sp.toString();
}
}
Mapper接口：UserMapper.java
package com.sunwii.mybatis.mapper;
import java.util.List;
import com.sunwii.mybatis.bean.User;
public interface UserMapper {
public User selectById(int id);
public List<User> selectByName(String name);
public int insert(User user);
public int update(User user);
public int delete(int id);
}
映射文件：UserMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.sunwii.mybatis.mapper.UserMapper">
<select id="selectById" parameterType="Integer"
resultType="User">
select * from t_user where id = #{id}
</select> <select id="selectByName" parameterType="String"
resultType="User">
select * from t_user where name like "%"#{name}"%"
</select> <insert id="insert">
insert into
t_user(
name, birthday, vip, salary, height, lastlogin,level,state,sex,tels
)values(
#{name},
#{birthday},
#{vip},
#{salary},
#{height},
#{lastlogin},
#{level},
#{state},
#{sex},
#{tels,typeHandler=com.sunwii.mybatis.typehandle.ListTypeHandler}
)
</insert> <update id="update">
update t_user set
name=#{name},
birthday=#{birthday},
vip=#{vip},
salary=#{salary},
height=#{height},
lastlogin=#{lastlogin},
level=#{level},
state=#{state},
sex=#{sex},
tels=#{tels,typeHandler=com.sunwii.mybatis.typehandle.ListTypeHandler}
where id=#{id}
</update> <delete id="delete" parameterType="Integer">
delete from t_user where
id=#{id}
</delete>
</mapper>
日期工具：CurrentUtil.java
package com.sunwii.mybatis.util; import java.sql.Timestamp;
import java.util.Date; public class CurrentUtil {
public static long currentTime() {
return new Date().getTime();
} public static Date currentDate() {
return new Date();
} public static java.sql.Date currentSqlDate() {
return new java.sql.Date(currentTime());
} public static Timestamp currentTimestamp() {
return new java.sql.Timestamp(currentTime());
}
}
测试示例：
package com.sunwii.mybatis.test.mapper; import java.util.Arrays;
import java.util.List; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.junit.Test; import com.sunwii.mybatis.bean.User;
import com.sunwii.mybatis.enums.Level;
import com.sunwii.mybatis.enums.Sex;
import com.sunwii.mybatis.enums.State;
import com.sunwii.mybatis.mapper.UserMapper;
import com.sunwii.mybatis.test.insert.TestInsert;
import com.sunwii.mybatis.util.CurrentUtil;
import com.sunwii.mybatis.util.SessionFactoryUtil; public class testMapper {
private static Log log = LogFactory.getLog(TestInsert.class);
private static SqlSessionFactory sf = SessionFactoryUtil.creat("mybatis-config.xml", true); @Test
public void testMapperInsert() {
User user = new User();
//user.setId(50);
user.setName("sunwii");
user.setVip(1);
user.setSalary(3333.00);
user.setHeight(1.70f);
user.setBirthday(CurrentUtil.currentDate());
user.setLastlogin(CurrentUtil.currentTimestamp());
user.setLevel(Level.LEVEL_3);
user.setState(State.OK);
user.setSex(Sex.WOMAN);
user.setTels(Arrays.asList("133xxxxxxx", "159xxxxxxxx")); int rs = 0;
SqlSession session = sf.openSession();
UserMapper userMapper = session.getMapper(UserMapper.class);
try {
rs = userMapper.insert(user);
session.commit();
} catch (Exception e) {
rs = 0;
session.rollback();
e.printStackTrace();
} finally {
session.close();
} log.info("操作结果：" + rs); } @Test
public void testMapperUpdate() {
User user = new User();
user.setId(1);
user.setName("sunwii--55550");
user.setVip(1);
user.setSalary(3333.00);
user.setHeight(1.70f);
user.setBirthday(CurrentUtil.currentDate());
user.setLastlogin(CurrentUtil.currentTimestamp());
user.setLevel(Level.LEVEL_2);
user.setState(State.ERROR);
user.setSex(Sex.MAN);
user.setTels(Arrays.asList("136xxxxxx", "139xxxxxxx")); int rs = 0;
SqlSession session = sf.openSession();
UserMapper userMapper = session.getMapper(UserMapper.class);
try {
rs = userMapper.update(user);
session.commit();
} catch (Exception e) {
rs = 0;
session.rollback();
e.printStackTrace();
} finally {
session.close();
} log.info("操作结果：" + rs); } @Test
public void testMapperDelete() {
User user = new User(50); int rs = 0;
SqlSession session = sf.openSession();
UserMapper userMapper = session.getMapper(UserMapper.class);
try {
rs = userMapper.delete(user.getId());
session.commit();
} catch (Exception e) {
rs = 0;
session.rollback();
e.printStackTrace();
} finally {
session.close();
} log.info("操作结果：" + rs); } @Test
public void testMapperGetOne() {
Integer id = 50;
User user = null;
SqlSession session = sf.openSession();
UserMapper userMapper = session.getMapper(UserMapper.class);
user = userMapper.selectById(id); log.info(user); } @Test
public void testMapperGetList() {
String userName = "sunwii"; List<User> users = null;
SqlSession session = sf.openSession();
UserMapper userMapper = session.getMapper(UserMapper.class);
users = userMapper.selectByName(userName); for (User user : users) {
log.info(user);
} }
}
<<Mybatis如何自动生成数据库表结构>>
说明：
这里多余的步骤仅仅是为了存档下代码（以及方便一些初学者不看代码不知道怎么回事的原因:里边涉及了各种常用类型的转换和映射）。
本文中最重要的就是Hibernate的几个包的选取，以及配置文件的精简，还有就是加载Hibernate的SessionFactory的方法。
这些说来说去都是Hibernate的东西。跟Mybatis原本是没有一点关系的。只不过需要用于，那纯属相当于复习一下Hibernate了。
Mybatis总结之如何自动生成数据库表结构的更多相关文章
- 【工具篇】利用DBExportDoc V1.0 For MySQL自动生成数据库表结构文档
对于DBA或开发来说,如何规范化你的数据库表结构文档是灰常之重要的一件事情.但是当你的库,你的表排山倒海滴多的时候,你就会很头疼了. 推荐一款工具DBExportDoc V1.0 For MySQL( ...
- 利用DBExportDoc V1.0 For MySQL自动生成数据库表结构文档
对于DBA或开发来说,如何规范化你的数据库表结构文档是灰常之重要的一件事情.但是当你的库,你的表排山倒海滴多的时候,你就会很头疼了. 推荐一款工具DBExportDoc V1.0 For MySQL( ...
- oracle数据库自动生成数据库表结构文档(亲测有效)
import java.awt.Color; import java.io.FileOutputStream; import java.sql.Connection; import java.sql. ...
- Hibernate由model类自动同步数据库表结构
在开发中遇到了个问题,每次测试数据库增加表结构的时候,本地pull下最新代码导致启动报错,上网搜了快速解决办法---->hibernate 配置属性中,hibernate.hbm2ddl.aut ...
- EF-使用迁移技术让程序自动更新数据库表结构
承接上一篇文章:关于类库中EntityFramework之CodeFirst(代码优先)的操作浅析 本篇讲述的是怎么使用迁移技术让程序自动通过ORM框架将模型实体类结构映射到现有数据库,并新增或修改与 ...
- EntityFramework Core 2.x （ef core） 在迁移中自动生成数据库表和列说明
在项目开发中有没有用过拼音首字母做列名或者接手这样的项目? 看见xmspsqb(项目审批申请表)这种表名时是否有一种无法抑制的想肛了取名的老兄的冲动? 更坑爹的是这种数据库没有文档(或者文档老旧不堪早 ...
- SQL SERVER 自动生成 MySQL 表结构及索引 的建表SQL
SQL SERVER的表结构及索引转换为MySQL的表结构及索引,其实在很多第三方工具中有提供,比如navicat.sqlyog等,但是,在处理某些数据类型.默认值及索引转换的时候,总有些 ...
- 【VBA】EXCEL通过VBA生成SQL，自动生成创建表结构SQL
原文:https://blog.csdn.net/zutsoft/article/details/45441343 编程往往与数据库密不可分,一个项目往往有很多的表,很多时候通过excel来维护表结构 ...
- EF CodeFirst关于Mysql如何自动生成数据库表
相对于sqlserver数据库,mysql的配置过程相对麻烦一些,我们从0讲起. 1.新建一个控制台应用程序 右键点击引用--管理NuGet程序包,搜索Mysql.Data.Entity并安装,安装完 ...
随机推荐
- WordPress后台地址路径修改方法
用过WordPress后台的,其实都知道http://域名目录/wp-login.php就是登录地址,如果这时候使用暴力破解,很可能破解密码(这就有些想象力了),下面芝麻带你看看如何自定义美观的地址. ...
- java自学小测试 九九乘法表
public class Ninenine { public static void main(String[] args) { for(int i=1;i<=9;i++){ for(int j ...
- 23种设计模式之装饰器模式(Decorator Pattern)
装饰器模式(Decorator Pattern) 允许向一个现有的对象添加新的功能,同时又不改变其结构.这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装. 这种模式创建了一个装饰类,用来包 ...
- SharePoint 2013 Create Folder with conententtype programer
记录一下昨天写的SharePoint tool,需求是这样的: 在SharePoint list subfolder 下创建1000个folder,这些folder指定特殊的contenttype,c ...
- js深度克隆对象、数组
function deepCopy(o) { if (o instanceof Array) { var n = []; for (var i = 0; i < o.length; ++i) { ...
- tomcat 配置jvm参数
设置JVM参数在Windows下,在$TOMCAT_HOME/bin/catalina.bat,Linux下,在$TOMCAT_HOME/bin/catalina.sh的前面,增加如下设置: JAVA ...
- useradd、id、userdel、usermod、chsh、passwd、pwck
1.useradd [-cdefgGmkMsu] 用户名称 用来添加用户 -c “备注“:加上备注文字 -d 路径:指定家目录 -e 有效期限:指定帐号的有效期限: -f 缓冲天数:指定在密码过期后多 ...
- sort，uniq，wc，tr
sort (选项)(参数) sort是用来排序数据的. 以下面这个文本为例 [root@bogon ~]# cat a 123 4567 88 abc aaa AAA jk 777 777 ...
- Java 多线程爬虫及分布式爬虫架构探索
这是 Java 爬虫系列博文的第五篇,在上一篇 Java 爬虫服务器被屏蔽,不要慌,咱们换一台服务器 中,我们简单的聊反爬虫策略和反反爬虫方法,主要针对的是 IP 被封及其对应办法.前面几篇文章我们把 ...
- JVM Java字节码的角度分析switch的实现
目录 Java字节码的角度分析switch的实现 引子 前置知识 一个妥协而又枯燥的方案 switch的实现 回顾历史 字节码分析 其他实现方式? Java字节码的角度分析switch的实现 作者 k ...