Mybatis基于注解形式的sql語句生成實例代碼
更新時間：2017年09月11日 14:07:06 作者：jjb_hz
這篇文章主要介紹了 Mybatis基于注解形式的sql語句生成實例代碼,需要的朋友可以參考下
對其做了些優(yōu)化，但此種sql生成方式僅適用于復雜程度不高的sql，所以實用性不是很高，僅僅是寫著玩的，知道點mybatis的注解形式的使用方式，可能以后會逐漸完善起來。第一次寫博客，寫的簡單點。
package com.bob.config.mvc.mybatis;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 實體類對應的列
*
* @author jjb
* @create 2017-09-08 14:42
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.METHOD})
public @interface Column {
/**
* 當前屬性對應的列名
*
* @return
*/
String value() default "";
/**
* 當前屬性是不是表必須的
*
* @return
*/
boolean required() default true;
}
package com.bob.config.mvc.mybatis;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 實體類對應的表
*
* @author jjb
* @create 2017-09-08 14:44
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface Table {
String value() default "";
/**
* 當前表的主鍵
*
* @return
*/
String key();
}
package com.bob.config.mvc.mybatis;
import org.apache.ibatis.annotations.DeleteProvider;
import org.apache.ibatis.annotations.InsertProvider;
import org.apache.ibatis.annotations.Options;
import org.apache.ibatis.annotations.SelectProvider;
import org.apache.ibatis.annotations.UpdateProvider;
/**
* Mybatis基礎Mapper
*
* @author jjb
* @create 2017-09-08 14:37
*/
public interface BaseMapper<T> {
/**
* 插入語句
*
* @param bean
* @return
*/
@Options(useGeneratedKeys = true)
@InsertProvider(type = SqlProvider.class, method = "insert")
public int insert(T bean);
/**
* 刪除語句
*
* @param bean
* @return
*/
@DeleteProvider(type = SqlProvider.class, method = "delete")
public int delete(T bean);
/**
* 更新語句
*
* @param bean
* @return
*/
@UpdateProvider(type = SqlProvider.class, method = "update")
public int update(T bean);
/**
* 查找語句
*
* @param bean
* @return
*/
@SelectProvider(type = SqlProvider.class, method = "select")
public T findFirst(T bean);
}
package com.bob.config.mvc.mybatis;
import java.time.LocalDate;
/**
* Mybatis實體類
*
* @author jjb
* @create 2017-09-08 17:16
*/
@Table(key = "id")
public class MybatisEntity {
@Column()
private String id;
@Column("USER_NAME")
private String name;
@Column()
private Integer age;
private LocalDate date;
@Column("ADRESS_NUMBER")
private Integer userAdressNumber;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Column("CUR_DATE")
public LocalDate getDate() {
return date;
}
public void setDate(LocalDate date) {
this.date = date;
}
public Integer getUserAdressNumber() {
return userAdressNumber;
}
public void setUserAdressNumber(Integer userAdressNumber) {
this.userAdressNumber = userAdressNumber;
}
}
package com.bob.config.mvc.mybatis;
import java.lang.reflect.Field;
import java.util.Map;
/**
* 表到實體的格式化器
*
* @author jjb
* @create 2017-09-08 14:51
*/
public interface TableFormatter {
/**
* 根據(jù)屬性獲取字段名稱
*
* @param field
* @return
*/
public String getColumnName(Field field);
/**
* 獲取主鍵屬性對應的列名
*
* @return
*/
public String getKeyColumnName(Class<?> clazz);
/**
* 獲取主鍵的屬性名稱
*
* @param clazz
* @return
*/
public String getKeyFiledName(Class<?> clazz);
/**
* 根據(jù)類獲取表名稱
*
* @param clazz
* @return
*/
public String getTableName(Class<?> clazz);
/**
* 獲取一個類的所有屬性的映射信息
*
* @param clazz
* @return
*/
public Map<Field, String> getFieldMappings(Class<?> clazz);
}
package com.bob.config.mvc.mybatis;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.HashMap;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;
import org.springframework.util.ReflectionUtils;
import org.springframework.util.StringUtils;
/**
* 依據(jù)駝峰原則來將表的信息格式化為實體類的信息，在駝峰處改小寫同時插入下劃線
*
* @author jjb
* @create 2017-09-08 14:55
*/
@Component
public class HumpToUnderLineFormatter implements TableFormatter {
private static final Logger LOGGER = LoggerFactory.getLogger(HumpToUnderLineFormatter.class);
private static final Map<Class<?>, Map<Field, String>> FIELD_TO_COLUMN_MAPPINGS = new HashMap<Class<?>, Map<Field, String>>();
private static final Map<Class, String> CLASS_TO_TABLE_MAPPING = new HashMap<Class, String>();
private static final StringBuilder SB = new StringBuilder();
private static final Object LOCK = new Object();
@Override
public String getColumnName(Field field) {
Assert.notNull(field, "屬性不能為空");
Map<Field, String> mappings = FIELD_TO_COLUMN_MAPPINGS.get(field.getDeclaringClass());
if (mappings == null) {
synchronized (LOCK) {
mappings = FIELD_TO_COLUMN_MAPPINGS.get(field.getDeclaringClass());
if (mappings == null) {
mappings = buildMapping(field.getDeclaringClass());
}
}
}
return mappings.get(field);
}
@Override
public String getKeyColumnName(Class<?> clazz) {
Table table = checkClass(clazz);
return getColumnName(ReflectionUtils.findField(clazz,table.key()));
}
@Override
public String getKeyFiledName(Class<?> clazz) {
Table table = checkClass(clazz);
Field field = ReflectionUtils.findField(clazz,table.key());
Assert.state(field != null,"@Table的key()指定的屬性必須存在");
return field.getName();
}
private Table checkClass(Class<?> clazz){
Assert.isTrue(clazz != null , "與Table對應的Class不能為空");
Table table = clazz.getAnnotation(Table.class);
Assert.isTrue(table != null && StringUtils.hasText(table.key()),"["+clazz.getName()+"]必須標識@Table注解且key()不能為空");
return table;
}
@Override
public String getTableName(Class<?> clazz) {
Assert.notNull(clazz, "類不能為空");
Assert.isTrue(clazz.isAnnotationPresent(Table.class), "[" + clazz.getName() + "]類上必須含有@Table注解");
String name = CLASS_TO_TABLE_MAPPING.get(clazz);
if (name == null) {
synchronized (LOCK) {
name = CLASS_TO_TABLE_MAPPING.get(clazz);
if (name == null) {
buildMapping(clazz);
}
}
}
return CLASS_TO_TABLE_MAPPING.get(clazz);
}
@Override
public Map<Field, String> getFieldMappings(Class<?> clazz) {
Assert.isTrue(clazz != null && clazz.isAnnotationPresent(Table.class), "與Table對應的Class不能為空且必須標識@Table注解");
Map<Field, String> mappings = FIELD_TO_COLUMN_MAPPINGS.get(clazz);
if (mappings == null) {
synchronized (LOCK) {
mappings = FIELD_TO_COLUMN_MAPPINGS.get(clazz);
if (mappings == null) {
mappings = buildMapping(clazz);
}
}
}
return FIELD_TO_COLUMN_MAPPINGS.get(clazz);
}
/**
* 創(chuàng)建實體到表映射
*
* @param clazz
*/
private Map<Field, String> buildMapping(Class<?> clazz) {
buildClassToTableMapping(clazz);
Map<Field, String> mappings = new HashMap<Field, String>();
FIELD_TO_COLUMN_MAPPINGS.put(clazz, mappings);
buildFiledToColumnMapping(clazz, mappings);
buildFiledToColumnMappingWithGetter(clazz, mappings);
return mappings;
}
/**
* 創(chuàng)建類名到表名的名稱映射
*
* @param clazz
*/
private void buildClassToTableMapping(Class<?> clazz) {
Table table = clazz.getAnnotation(Table.class);
Assert.notNull(table, "[" + clazz.getName() + "]類上必須有@Table注解");
CLASS_TO_TABLE_MAPPING.put(clazz, StringUtils.hasText(table.value()) ? table.value() : doFormatWithHunmRule(clazz.getSimpleName()));
}
/**
* 通過Filed建立屬性名稱到字段名稱的映射
*
* @param clazz
* @param mappings
*/
private void buildFiledToColumnMapping(Class<?> clazz, Map<Field, String> mappings) {
ReflectionUtils.doWithLocalFields(clazz, (field) -> {
Column column = field.getAnnotation(Column.class);
if (column != null) {
if (Modifier.isStatic(field.getModifiers())) {
LOGGER.error("[{}]注解不適用于靜態(tài)方法:[{}]", Column.class.toString(), field);
return;
}
mappings.put(field, StringUtils.hasText(column.value()) ? column.value() : doFormatWithHunmRule(field.getName()));
}
}
);
}
/**
* 通過getter()建立屬性名稱到字段名稱的映射
*
* @param clazz
* @param mappings
*/
private void buildFiledToColumnMappingWithGetter(Class<?> clazz, Map<Field, String> mappings) {
ReflectionUtils.doWithLocalMethods(clazz, (method) -> {
Column column = method.getAnnotation(Column.class);
if (column != null) {
if (Modifier.isStatic(method.getModifiers())) {
LOGGER.warn("[{}]注解不適用于靜態(tài)方法: [{}]", Column.class.toString(), method);
return;
}
if (!method.getName().startsWith("get") || method.getParameterTypes().length > 0) {
LOGGER.warn("[{}]注解只適用于getter方法,而非: [{}]方法", Column.class.toString(), method);
return;
}
String fieldName = BeanUtils.findPropertyForMethod(method).getName();
mappings.put(ReflectionUtils.findField(clazz, fieldName),
StringUtils.hasText(column.value()) ? column.value() : doFormatWithHunmRule(fieldName));
}
}
);
}
/**
* 依據(jù)駝峰原則格式化屬性或者類名稱,在駝峰處改小寫同時前一位插入下劃線,忽略首字母
*
* @param name
* @return
*/
private static String doFormatWithHunmRule(String name) {
Assert.hasText(name, "屬性或者類名稱不能為空");
SB.delete(0, SB.length());
SB.append(toUpperCase(name.charAt(0)));
for (int i = 1; i < name.length(); i++) {
if (isUpperCase(name.charAt(i))) {
SB.append("_");
}
SB.append(toUpperCase(name.charAt(i)));
}
return SB.toString();
}
/**
* 將字符轉換為大寫
*
* @param ch
* @return
*/
private static char toUpperCase(char ch) {
return Character.toUpperCase(ch);
}
/**
* 判斷是否為大寫
*
* @param ch
* @return
*/
private static boolean isUpperCase(char ch) {
return Character.isUpperCase(ch);
}
}
package com.bob.config.mvc.mybatis;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.Map.Entry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.StringUtils;
/**
* Mybatis的SQL語句供應器
*
* @author jjb
* @create 2017-09-08 14:37
*/
public class SqlProvider {
private static final Logger LOGGER = LoggerFactory.getLogger(SqlProvider.class);
private TableFormatter tableFormat = new HumpToUnderLineFormatter();
/**
* 根據(jù)Bean對象生成插入SQL語句
*
* @param bean
* @return
*/
public String insert(Object bean) {
Class<?> beanClass = bean.getClass();
String tableName = tableFormat.getTableName(beanClass);
StringBuilder insertSql = new StringBuilder();
List<String> columns = new ArrayList<String>();
List<String> values = new ArrayList<String>();
insertSql.append("INSERT INTO ").append(tableName).append("(");
try {
for (Entry<Field, String> entry : tableFormat.getFieldMappings(beanClass).entrySet()) {
Field field = entry.getKey();
field.setAccessible(true);
if (field.get(bean) != null) {
columns.add(entry.getValue());
values.add("#{" + field.getName() + "}");
}
}
} catch (Exception e) {
new RuntimeException("get insert sql has exceptoin:" + e);
}
int columnSize = columns.size();
for (int i = 0; i < columnSize; i++) {
insertSql.append(columns.get(i));
insertSql.append(i != columnSize - 1 ? "," : ") VALUES(");
}
for (int i = 0; i < columnSize; i++) {
insertSql.append(values.get(i));
insertSql.append(i != columnSize - 1 ? "," : ")");
}
return insertSql.toString();
}
/**
* 根據(jù)Bean對象生成更新SQL語句
*
* @param bean
* @return
*/
public String update(Object bean) {
Class<?> beanClass = bean.getClass();
String tableName = tableFormat.getTableName(beanClass);
StringBuilder updateSql = new StringBuilder();
updateSql.append(" UPDATE ").append(tableName).append(" SET ");
try {
for (Entry<Field, String> entry : tableFormat.getFieldMappings(beanClass).entrySet()) {
Field field = entry.getKey();
field.setAccessible(true);
if (field.get(bean) != null) {
updateSql.append(entry.getValue()).append("=#{").append(field.getName()).append("},");
}
}
updateSql.deleteCharAt(updateSql.length() - 1);
} catch (Exception e) {
new RuntimeException("get update sql is exceptoin:" + e);
}
updateSql.append(" WHERE ").append(tableFormat.getKeyColumnName(beanClass) + " =#{" + tableFormat.getKeyFiledName(beanClass) + "}");
return updateSql.toString();
}
/**
* 根據(jù)Bean對象生成刪除SQL語句
*
* @param bean
* @return
*/
public String delete(Object bean) {
Class<?> beanClass = bean.getClass();
String tableName = tableFormat.getTableName(beanClass);
StringBuilder deleteSql = new StringBuilder();
deleteSql.append(" DELETE FROM ").append(tableName).append(" WHERE ");
try {
for (Entry<Field, String> entry : tableFormat.getFieldMappings(beanClass).entrySet()) {
Field field = entry.getKey();
field.setAccessible(true);
if (field.get(bean) != null) {
deleteSql.append(entry.getValue()).append("=#{").append(field.getName()).append("} AND ");
}
}
deleteSql.delete(deleteSql.length() - 5, deleteSql.length() - 1);
} catch (Exception e) {
new RuntimeException("get delete sql is exceptoin:" + e);
}
return deleteSql.toString();
}
/**
* 生成查詢SQL語句
*
* @param bean
* @return
*/
public String select(Object bean) {
Class<?> beanClass = bean.getClass();
String tableName = tableFormat.getTableName(beanClass);
StringBuilder selectSql = new StringBuilder();
List<String> columns = new ArrayList<String>();
List<String> values = new ArrayList<String>();
selectSql.append("SELECT ");
try {
for (Entry<Field, String> entry : tableFormat.getFieldMappings(beanClass).entrySet()) {
Field field = entry.getKey();
field.setAccessible(true);
selectSql.append(entry.getValue() + ",");
if (field.get(bean) != null) {
columns.add(entry.getValue());
values.add("#{" + field.getName() + "}");
}
}
selectSql.deleteCharAt(selectSql.length() - 1);
} catch (Exception e) {
new RuntimeException("get select sql is exceptoin:" + e);
}
selectSql.append(" FROM ").append(tableName).append(" WHERE ");
int columnSize = columns.size();
for (int i = 0; i < columnSize; i++) {
selectSql.append(columns.get(i)).append("=").append(values.get(i)).append(" AND ");
}
selectSql.delete(selectSql.length() - 5, selectSql.length() - 1);
return selectSql.toString();
}
}
package com.bob.test.concrete.mysqlGenerate;
import java.time.LocalDate;
import com.bob.config.mvc.mybatis.MybatisEntity;
import com.bob.config.mvc.mybatis.SqlProvider;
import org.junit.Before;
import org.junit.Test;
/**
* Mysql基于注解形式的sql語句生成測試
*
* @author jjb
* @create 2017-09-11 11:10
*/
public class MysqlGenerateTest {
private SqlProvider sqlProvider;
private MybatisEntity mybatisEntity;
@Before
public void doBefore(){
sqlProvider = new SqlProvider();
mybatisEntity = new MybatisEntity();
mybatisEntity.setId("0015415");
mybatisEntity.setName("lanboal");
mybatisEntity.setAge(28);
mybatisEntity.setDate(LocalDate.now());
mybatisEntity.setUserAdressNumber(24);
}
@Test
public void testInsert(){
String sql = sqlProvider.insert(mybatisEntity);
System.out.println(sql);
}
@Test
public void testUpdate(){
String sql = sqlProvider.update(mybatisEntity);
System.out.println(sql);
}
@Test
public void testDelete(){
String sql = sqlProvider.delete(mybatisEntity);
System.out.println(sql);
}
@Test
public void testSelect(){
String sql = sqlProvider.select(mybatisEntity);
System.out.println(sql);
}
}
總結
以上所述是小編給大家介紹的 Mybatis基于注解形式的sql語句生成實例代碼，希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回復大家的。在此也非常感謝大家對腳本之家網(wǎng)站的支持！
您可能感興趣的文章:
- Mybatis控制臺打印Sql語句的實現(xiàn)代碼
- MyBatis 執(zhí)行動態(tài) SQL語句詳解
- 詳解Java的MyBatis框架中SQL語句映射部分的編寫
- Oracle在Mybatis中SQL語句的配置方法
- Mybatis中 SQL語句復用
- mybatis教程之動態(tài)sql語句_動力節(jié)點Java學院整理
- 詳解MyBatis直接執(zhí)行SQL查詢及數(shù)據(jù)批量插入
- mybatis執(zhí)行批量更新batch update 的方法（oracle,mysql兩種）
- Mybatis 中的sql批量修改方法實現(xiàn)
- 如何批量測試Mybatis項目中的Sql是否正確詳解
相關文章
這篇文章主要介紹了SpringBoot分離打Jar包的兩種配置方式，方式一是基于maven-jar-plugin，方式二是基于spring-boot-maven-plugin，文中結合實例代碼給大家介紹的非常詳細,需要的朋友可以參考下2022-11-11
這篇文章主要介紹了Spring中使用@Value注解注入屬性文件中的值詳解,通過Spring的@Value注解可以將xml中關聯(lián)的屬性文件中的值注入變量中,這樣就不需要通過創(chuàng)建Properties然后根據(jù)屬性文件讀取屬性值了,需要的朋友可以參考下2023-12-12
Java實現(xiàn)統(tǒng)計字符串出現(xiàn)的次數(shù)
這篇文章主要為大家詳細介紹了Java實現(xiàn)統(tǒng)計字符串出現(xiàn)的次數(shù)，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-10-10
我們知道 Java 8 增加了一些很有用的 API, 其中一個就是 Optional，下面這篇文章主要給大家介紹了關于如何正確使用Java8中Optional機制的相關資料，文中通過示例代碼介紹的非常詳細，需要的朋友可以參考借鑒，下面來一起看看吧。2017-11-11
這篇文章主要介紹了SpringBoot如何整合JSP和MyBatis以及SpringBoot的基本設置，感興趣的小伙伴可以參考閱讀2023-03-03
在linux操作時,經常要查看運行的項目的進程和端口,下面這篇文章主要給大家介紹了關于如何查看Linux上正在運行的所有Java程序列表的相關資料,需要的朋友可以參考下2023-10-10
在我們進行項目編寫時,有時相同的一段代碼在不同的地方使用多次,對于這種情況,spring 幫我們實現(xiàn)了統(tǒng)一功能處理,下面介紹一些常用的統(tǒng)一功能處理,感興趣的朋友一起看看吧2025-04-04
解決創(chuàng)建springboot后啟動報錯:Failed?to?bind?properties?under‘spri
在Spring?Boot項目中,application.properties和application.yml是用于配置參數(shù)的兩種文件格式,properties格式簡潔但不支持層次結構,而yml格式支持層次性,可讀性更好,在yml文件中,要注意細節(jié),比如冒號后面需要空格2024-10-10
文章介紹了Spring的IoC和DI機制,以及MyBatis的動態(tài)代理,通過注解和反射,Spring能夠自動管理對象的創(chuàng)建和依賴注入,而MyBatis則通過動態(tài)代理實現(xiàn)了接口方法到數(shù)據(jù)庫操作的映射,文章詳細解釋了Spring和MyBatis的工作原理,并通過示例代碼展示了它們的結合使用方式2025-01-01
本文將介紹如何使用Spring?Boot發(fā)送郵件,我們將演示如何配置SMTP郵件服務器,創(chuàng)建一個郵件模板,以及如何使用JavaMailSender發(fā)送郵件,我們還將介紹如何測試我們的郵件發(fā)送代碼2023-12-12