mybatis注解实现动态sql

最新推荐文章于 2024-04-28 22:19:56 发布
最新推荐文章于 2024-04-28 22:19:56 发布
阅读量1.4w 收藏 4
点赞数 1
分类专栏： mybatis 文章标签： 动态sql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hsgao_water/article/details/52230246
版权

传统情况下，我们使用mybatis，都是通过映射文件获取sql。在这里，我们通过对实体添加注解类，在调用的过程中，通过对实体参数对象和注解类进行解析，获取到动态的sql。

大致流程：


如图，我们创建一个Test类，Test类调用具体的Dao，而Dao通过调用IBatisDaoUtils和DynamicSql工具类获取到动态的sql，从而通过sqlMapClientTemplate实现访问数据库的功能。

mybatis配置spring-ibatis.xml

	<context:component-scan base-package="com"/>
	<!-- 数据 -->
	<bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
		<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
		<property name="url" value="jdbc:mysql://localhost:3306/lpWeb"/>
		<property name="username" value="root"/>
		<property name="password" value="root123"/>
	</bean>
	
	<bean id="sqlMapClient" class="org.springframework.orm.ibatis.SqlMapClientFactoryBean">
		<property name="configLocation" value="classpath:/sql-map-config.xml"/>
		<property name="dataSource" ref="dataSource"/>
	</bean>
	
	 <bean id="sqlMapClientTemplate" class="org.springframework.orm.ibatis.SqlMapClientTemplate">    
        <property name="sqlMapClient" ref="sqlMapClient"/>   
    </bean>
  
	 <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"/>
	</bean>

映射文件

sql-map-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMapConfig PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN"
"http://ibatis.apache.org/dtd/sql-map-config-2.dtd">
<sqlMapConfig>
<settings cacheModelsEnabled="true" enhancementEnabled="true"
		lazyLoadingEnabled="true" maxRequests="320" maxSessions="100"
		maxTransactions="100" useStatementNamespaces="true" />
	<sqlMap resource="file.xml"/>
	<sqlMap resource="dynamicSqlMapper.xml"/>
</sqlMapConfig>
<pre name="code" class="html">

dynamicSqlMapper.xml

 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd">
<sqlMap namespace="GenericSql">

	<statement id="SelectObjectVOSql" parameterClass="java.util.HashMap"
		resultClass="java.util.HashMap" remapResults="true">
		select
		<isNotEmpty property="sqlvalue">
			$sqlvalue$
		</isNotEmpty>
		from
		<isNotEmpty property="sqltablename">
			$sqltablename$
		</isNotEmpty>
		<dynamic prepend="where">
			<isNotNull property="sqlwhere">
				<iterate prepend=" " property="sqlwhere" conjunction=",">
					$sqlwhere[].key$ = #sqlwhere[].value#
				</iterate>
			</isNotNull>
		</dynamic>
	</statement>
</sqlMap>

 

 Test 

 

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:/spring-ibatis.xml" })
public class TestNewsDao {

	@Autowired
	BaseDao baseDao;
	
	@Test
	public void testNew() {
		try {
			NewsDto newsDto = new NewsDto();
			newsDto.setNewsId(1);
			newsDto = (NewsDto) baseDao.getRow(newsDto);
			System.out.println(newsDto);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
 

 NewsDaoImpl 

 

 

@Scope("prototype")
@Service("newsDao")
public class NewsDaoImpl extends BaseDaoImpl<NewsDto,String> implements INewsDao{

	public NewsDaoImpl() {
		super(NewsDto.class);
	}

}
 

 INewsDao 

 

 

 

public interface INewsDao {

}

 

 BaseDaoImpl 

 

 

 

package com.file.dao;

import java.io.Serializable;
import java.util.List;

import javax.annotation.Resource;

import org.springframework.orm.ibatis.SqlMapClientTemplate;

import com.entity.IBaseDto;
import com.sql.DynamicSql;
import com.util.IBatisDaoUtils;

public abstract class BaseDaoImpl<T extends IBaseDto, PK extends Serializable> 
		implements BaseDao<T, PK> {

	@Resource(name = "sqlMapClientTemplate")
	private SqlMapClientTemplate sqlMapClientTemplate;
	
	private Class<T> persistentClass;

	public BaseDaoImpl(Class<T> persistentClass) {
		this.persistentClass = persistentClass;
	}

	private List<T> getAll(T object, String tableName) {
		List list = sqlMapClientTemplate.queryForList("GenericSql.SelectObjectVOSql",
				DynamicSql.getInstance().SelectSql(object, tableName));

		  return DynamicSql.getInstance().ListHashToListbean(list, object);
	}

	public List<T> getAll(T object) {
		return getAll(object, IBatisDaoUtils.getTableName(object));
	}


	private T getRow(T object, String tableName) {
		List list = getAll(object, tableName);
		if ((list != null) && (list.size() > 0)) {
			T ob = (T) list.get(0);
			return ob;
		}
		return null;
	}

	public T getRow(T object){
		return getRow(object, IBatisDaoUtils.getTableName(object));
	}

	public boolean existsPhysicallyData(T object) {
		return exists(object, IBatisDaoUtils.getTableName(object));
	}

	public boolean exists(T object) {
		return exists(object, IBatisDaoUtils.getTableName(object));
	}

	private boolean exists(T object, String tableName) {
		Integer countNum = (Integer) sqlMapClientTemplate.queryForObject("GenericSql.SelectCountObjectVOSql",
				DynamicSql.getInstance().SelectCountSql(object, tableName));

		if (countNum.intValue() > 0) {
			return true;
		}
		return false;
	}
}

BaseDao 

 

package com.file.dao;

import java.io.Serializable;
import java.util.List;

import com.entity.IBaseDto;
import com.exception.BusiException;

public abstract interface BaseDao<T extends IBaseDto,PK extends Serializable> {
	
	  
	  public abstract List<T> getAll(T paramT);
	  
	  public abstract T getRow(T paramT);
	  
	  public abstract boolean exists(T paramT);
}

 

 IBatisDaoUtils 

 

 

dao工具类，这个是dao实现持久化和查询前进行的包装，及组装可使用的动态sql给dao备用。
 

 

package com.util;

import java.lang.reflect.Method;
import java.text.MessageFormat;

import org.springframework.util.ClassUtils;

import com.entity.EntityPK;
import com.entity.IBaseDto;
import com.exception.BusiException;

public final class IBatisDaoUtils {

	/**
	 * 获取表名
	 * 
	 * @param o
	 * @return
	 * @throws BusiException
	 */
	public static String getTableName(Object o) {
		// 获取对象o的注解类
		EntityPK entity = o.getClass().getAnnotation(EntityPK.class);

		if (entity == null || "".equals(entity)) {
			String msg = MessageFormat.format("Could not set '{0}' tableName",
					new Object[] { ClassUtils.getShortName(o.getClass()) });
		}

		// 如果注解类不为空，则获取table
		return entity.tableName();
	}

	/**
	 * 返回主键字段
	 * 
	 * @param o
	 * @return
	 */
	public static String getPrimaryKeyFieldName(Object o) {
		// 获取对象o的注解类
		EntityPK entity = o.getClass().getAnnotation(EntityPK.class);

		if (entity == null || "".equals(entity)) {
			return null;
		}
		return "".equals(entity.PK()) ? null : entity.PK();
	}

	public static Object getPrimaryKeyFieldValue(IBaseDto o) {
		String fieldName = getPrimaryKeyFieldName(o);
		if (fieldName == null) {
			return null;
		}
		// 获取get方法
		String getterMethod = "get" + Character.toUpperCase(fieldName.charAt(0)) + fieldName.substring(1);
		try {
			Method getMethod = o.getClass().getMethod(getterMethod, (Class[]) null);
			// 回调方法
			return getMethod.invoke(o, (Object[]) null);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}

	public static void setPrimaryKey(IBaseDto o, Object val) {
		String fieldName = "";
		try {
			fieldName = getPrimaryKeyFieldName(o);
			EntityPK entity = (EntityPK) o.getClass().getAnnotation(EntityPK.class);
			Class clazz = o.getClass().getDeclaredField(entity.PK()).getType();
			// 获取get方法
			String getterMethod = "set" + Character.toUpperCase(fieldName.charAt(0)) + fieldName.substring(1);

			Method setMethod = o.getClass().getMethod(getterMethod, (Class[]) null);
			if (val != null) {
				setMethod.invoke(o, new Object[] { val });
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			String msg = MessageFormat.format("Could not set '{0}.{1}' with value {2}",
					new Object[] { ClassUtils.getShortName(o.getClass()), fieldName, val });
		}
	}

	public static String getTableName(Object ob, String tableName) {
		if (tableName == null) {
			tableName = ClassUtils.getShortName(ob.getClass());
		}

		return tableName;
	}
}

 

 


 
 DynamicSql 

动态sql获取类，通过传入的实体对象，获取到动态的sql
 
 

package com.sql;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.Reader;
import java.lang.reflect.Field;
import java.sql.Clob;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.log4j.Logger;
import org.springframework.beans.BeanWrapper;
import org.springframework.beans.BeanWrapperImpl;

import com.entity.IBaseDto;
import com.util.IBatisDaoUtils;

import DynamicSql.KeyVO;

public class DynamicSql {
	private final Logger log = Logger.getLogger(getClass());

	private static DynamicSql m_instance = null;

	private void init() {
	}

	public static synchronized DynamicSql getInstance() {
		if (m_instance == null) {
			m_instance = new DynamicSql();
			m_instance.init();
		}

		return m_instance;
	}

	public HashMap<String, Object> beanTohashmap(Object ob) throws IllegalArgumentException, IllegalAccessException {
		Field[] field = ob.getClass().getDeclaredFields();

		HashMap map = new HashMap();

		for (int i = 0; i < field.length; i++) {
			Field f = field[i];
			f.setAccessible(true);
			map.put(f.getName(), f.get(ob));
		}

		return map;
	}

	public HashMap<String, Object> UpdatebeanToSqlPk(Object ob, String tableName) {
		HashMap sql_hs = new HashMap();

		ArrayList setsql = new ArrayList();

		ArrayList wherepk = new ArrayList();
		try {
			ObjectVOtoKeyVOListPK(ob, setsql, wherepk);

			if (wherepk.size() <= 0) {
				throw new RuntimeException("no pk value!!!!");
			}

			tableName = getTableName(ob, tableName);

			sql_hs.put("sqltablename", tableName);

			sql_hs.put("sqlvalue", setsql);

			sql_hs.put("sqlwhere", wherepk);
		} catch (IllegalArgumentException e) {
			this.log.error("::", e);
		} catch (IllegalAccessException e) {
			this.log.error("::", e);
		}

		return sql_hs;
	}

	public HashMap<String, Object> DeletebeanToSqlPk(Object ob, String tableName) {
		HashMap sql_hs = new HashMap();

		ArrayList wherepk = new ArrayList();
		try {
			ObjectVOtoKeyVOListForWherePK(ob, wherepk);

			if (wherepk.size() <= 0) {
				throw new RuntimeException("no pk value!!!");
			}

			tableName = getTableName(ob, tableName);

			sql_hs.put("sqltablename", tableName);

			sql_hs.put("sqlwhere", wherepk);
		} catch (IllegalArgumentException e) {
			this.log.error("::", e);
		} catch (IllegalAccessException e) {
			this.log.error("::", e);
		}

		return sql_hs;
	}

	public HashMap<String, Object> DeletebeanToSql(Object ob, String tableName) {
		HashMap sql_hs = new HashMap();

		ArrayList setsql = new ArrayList();
		try {
			ObjectVOtoKeyVOList(ob, setsql);

			tableName = getTableName(ob, tableName);

			sql_hs.put("sqltablename", tableName);

			sql_hs.put("sqlwhere", setsql);
		} catch (IllegalArgumentException e) {
			this.log.error("::", e);
		} catch (IllegalAccessException e) {
			this.log.error("::", e);
		}

		return sql_hs;
	}

	public HashMap<String, Object> SelectSql(Object ob, String tableName) {
		StringBuffer selectsql = new StringBuffer(" ");

		HashMap sql_hs = new HashMap();

		ArrayList<KeyVO> wheresetsql = new ArrayList<KeyVO>();
		try {
			ObjectVOtoKeyVOListSelect(ob, wheresetsql, selectsql);

			tableName = getTableName(ob, tableName);

			sql_hs.put("sqltablename", tableName);

			sql_hs.put("sqlvalue", selectsql.toString().substring(0, selectsql.toString().lastIndexOf(",")));

			sql_hs.put("sqlwhere", wheresetsql);
		} catch (IllegalArgumentException e) {
			this.log.error("::", e);
		} catch (IllegalAccessException e) {
			this.log.error("::", e);
		}

		return sql_hs;
	}

	public HashMap<String, Object> SelectCountSql(Object ob, String tableName) {
		StringBuffer selectsql = new StringBuffer(" ");

		HashMap sql_hs = new HashMap();

		ArrayList wheresetsql = new ArrayList();
		try {
			ObjectVOtoSelectCount(ob, wheresetsql);

			tableName = getTableName(ob, tableName);

			sql_hs.put("sqltablename", tableName);

			sql_hs.put("sqlwhere", wheresetsql);
		} catch (IllegalArgumentException e) {
			this.log.error("::", e);
		} catch (IllegalAccessException e) {
			this.log.error("::", e);
		}

		return sql_hs;
	}

	public HashMap<String, Object> InsertSql(Object ob, String tableName, Object tablePk) {
		StringBuffer selectsql = new StringBuffer("( ");

		HashMap sql_hs = new HashMap();

		ArrayList wheresetsql = new ArrayList();
		try {
			tableName = getTableName(ob, tableName);

			ObjectVOtoKeyVOListInsert(ob, wheresetsql, selectsql, tablePk);

			sql_hs.put("sqltablename", tableName);

			sql_hs.put("sqlvalue", selectsql.toString().substring(0, selectsql.toString().lastIndexOf(",")) + " ) ");

			sql_hs.put("sqlwhere", wheresetsql);
		} catch (IllegalArgumentException e) {
			this.log.error("::", e);
		} catch (IllegalAccessException e) {
			this.log.error("::", e);
		}

		return sql_hs;
	}

	private void ObjectVOtoKeyVOListPK(Object ob, ArrayList<KeyVO> keyVoList, ArrayList<KeyVO> wherePk)
			throws IllegalArgumentException, IllegalAccessException {
		Field[] field = getFields(ob);

		KeyVO thisvo = null;

		for (int i = 0; i < field.length; i++) {
			Field f = field[i];

			f.setAccessible(true);

			if (!f.getName().toUpperCase().equals("SERIALVERSIONUID")) {
				if (f.get(ob) != null) {
					String type = f.getType().getCanonicalName();

					if (CleanoutType(type)) {
						String selectColumn = f.getName();

						thisvo = new KeyVO();

						thisvo.setKey(selectColumn.toUpperCase());

						thisvo.setValue(f.get(ob));

						if (f.getName().toUpperCase()
								.equals(IBatisDaoUtils.getPrimaryKeyFieldName((IBaseDto) ob).toUpperCase())) {
							if (wherePk != null) {
								wherePk.add(thisvo);
							}

						} else {
							keyVoList.add(thisvo);
						}

						thisvo = null;
					}
				}
			}
		}
	}

	private void ObjectVOtoKeyVOListForWherePK(Object ob, ArrayList<KeyVO> wherePk)
			throws IllegalArgumentException, IllegalAccessException {
		Field[] field = getFields(ob);

		KeyVO thisvo = null;

		for (int i = 0; i < field.length; i++) {
			Field f = field[i];

			f.setAccessible(true);

			if (!f.getName().toUpperCase().equals("SERIALVERSIONUID")) {
				if (f.get(ob) != null) {
					String type = f.getType().getCanonicalName();

					if (CleanoutType(type)) {
						String selectColumn = f.getName();

						thisvo = new KeyVO();

						thisvo.setKey(selectColumn.toUpperCase());

						thisvo.setValue(f.get(ob));

						if (f.getName().toUpperCase()
								.equals(IBatisDaoUtils.getPrimaryKeyFieldName((IBaseDto) ob).toUpperCase())) {
							if (wherePk != null) {
								wherePk.add(thisvo);
							}

						}

						thisvo = null;
					}
				}
			}
		}
	}

	private void ObjectVOtoKeyVOList(Object ob, ArrayList<KeyVO> keyvolist)
			throws IllegalArgumentException, IllegalAccessException {
		Field[] field = ob.getClass().getDeclaredFields();

		KeyVO thisvo = null;

		for (int i = 0; i < field.length; i++) {
			Field f = field[i];

			f.setAccessible(true);

			if (!f.getName().toUpperCase().equals("SERIALVERSIONUID")) {
				if (f.get(ob) != null) {
					String type = f.getType().getCanonicalName();

					if (CleanoutType(type)) {
						String selectColumn = f.getName();

						thisvo = new KeyVO();

						thisvo.setKey(selectColumn.toUpperCase());

						thisvo.setValue(f.get(ob));

						keyvolist.add(thisvo);

						thisvo = null;
					}
				}
			}
		}
	}

	private void ObjectVOtoKeyVOListSelect(Object ob, ArrayList<KeyVO> whereKeyVoList, StringBuffer selectValue)
			throws IllegalArgumentException, IllegalAccessException {
		Field[] field = getFields(ob);

		KeyVO thisvo = null;

		for (int i = 0; i < field.length; i++) {
			Field f = field[i];

			f.setAccessible(true);

			if (!f.getName().toUpperCase().equals("SERIALVERSIONUID")) {
				String selectColumn = f.getName();

				String type = f.getType().getCanonicalName();

				if (CleanoutType(type)) {
					selectValue.append(selectColumn + " \"" + selectColumn + "\" , ");

					if (f.get(ob) != null) {
						thisvo = new KeyVO();

						thisvo.setKey(selectColumn.toUpperCase());

						thisvo.setValue(f.get(ob));

						whereKeyVoList.add(thisvo);

						thisvo = null;
					}
				}
			}
		}
	}

	private void ObjectVOtoSelectCount(Object ob, ArrayList<KeyVO> whereKeyVoList)
			throws IllegalArgumentException, IllegalAccessException {
		Field[] field = getFields(ob);

		KeyVO thisvo = null;

		for (int i = 0; i < field.length; i++) {
			Field f = field[i];

			f.setAccessible(true);

			if (!f.getName().toUpperCase().equals("SERIALVERSIONUID")) {
				String selectColumn = f.getName();

				String type = f.getType().getCanonicalName();

				if (f.get(ob) != null) {
					thisvo = new KeyVO();

					thisvo.setKey(selectColumn.toUpperCase());

					thisvo.setValue(f.get(ob));

					whereKeyVoList.add(thisvo);

					thisvo = null;
				}
			}
		}
	}

	private void ObjectVOtoKeyVOListInsert(Object ob, ArrayList<KeyVO> keyvolist, StringBuffer selectvalue,
			Object tablePk) throws IllegalArgumentException, IllegalAccessException {
		Field[] field = getFields(ob);

		KeyVO thisvo = null;

		for (int i = 0; i < field.length; i++) {
			Field f = field[i];

			f.setAccessible(true);

			if (f.getName().toUpperCase().equals(IBatisDaoUtils.getPrimaryKeyFieldName((IBaseDto) ob).toUpperCase())) {
				selectvalue.append(f.getName().toUpperCase() + ", ");

				thisvo = new KeyVO();

				thisvo.setKey(f.getName().toUpperCase());

				thisvo.setValue(tablePk);

				keyvolist.add(thisvo);
			} else if (f.get(ob) != null) {
				if (!f.getName().toUpperCase().equals("SERIALVERSIONUID")) {
					String selectColumn = f.getName();

					String type = f.getType().getCanonicalName();

					if (CleanoutType(type)) {
						selectvalue.append(selectColumn.toUpperCase() + ", ");

						thisvo = new KeyVO();

						thisvo.setKey(selectColumn.toUpperCase());

						thisvo.setValue(f.get(ob));

						keyvolist.add(thisvo);

						thisvo = null;
					}
				}
			}
		}
	}

	public HashMap<String, Object> UpdateBatchbeanToSqlPk(Object ob, List wherepk, String tableName) {
		HashMap sql_hs = new HashMap();

		ArrayList setsql = new ArrayList();
		try {
			ObjectVOtoKeyVOListPK(ob, setsql, null);

			tableName = getTableName(ob, tableName);

			sql_hs.put("sqltablename", tableName);

			sql_hs.put("sqlvalue", setsql);

			sql_hs.put("sqlwhere", wherepk);

			sql_hs.put("sqltablepkname", IBatisDaoUtils.getPrimaryKeyFieldName((IBaseDto) ob).toUpperCase());
		} catch (IllegalArgumentException e) {
			this.log.error("::", e);
		} catch (IllegalAccessException e) {
			this.log.error("::", e);
		}

		return sql_hs;
	}
	
	 public List ListHashToListbean(List list, Object model)
	  {
	    List beanlist = new ArrayList();
	    if (list != null) {
	      try {
	        for (int i = 0; i < list.size(); i++) {
	          Object ob = model.getClass().newInstance();
	          HashMap hs = (HashMap)list.get(i);
	          BeanWrapper beanWrapper = new BeanWrapperImpl(ob);
	          beanWrapper.setPropertyValues(hs);
	          beanlist.add(ob);
	        }
	      } catch (IllegalAccessException e) {
	        this.log.error("::", e);
	      } catch (InstantiationException e) {
	        this.log.error("::", e);
	      } catch (Exception e) {
	        this.log.error("::", e);
	      }
	    }
	    return beanlist;
	  }
	 
	private boolean CleanoutType(String type) {
		if ((type.equals("java.lang.Float")) || (type.equals("java.lang.Long")) || (type.equals("java.lang.String"))
				|| (type.equals("java.lang.Integer")) || (type.equals("java.lang.Double"))
				|| (type.equals("java.sql.Timestamp")) || (type.equals("java.math.BigDecimal"))
				|| (type.equals("java.util.Date")) || (type.equals("java.sql.Date"))) {
			return true;
		}
		return false;
	}

	private String getTableName(Object ob, String tableName) {
		return IBatisDaoUtils.getTableName(ob, tableName);
	}

	private Field[] getFields(Object ob) {
		Field[] field = ob.getClass().getDeclaredFields();
		return field;
	}

	private String clobToString(Clob clob) {
		String reString = "";
		Reader is = null;
		try {
			is = clob.getCharacterStream();
		} catch (SQLException e) {
			e.printStackTrace();
		}

		BufferedReader br = new BufferedReader(is);
		String s = null;
		try {
			s = br.readLine();
		} catch (IOException e) {
			e.printStackTrace();
		}
		StringBuffer sb = new StringBuffer();
		while (s != null) {
			sb.append(s);
			try {
				s = br.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		reString = sb.toString();
		return reString;
	}
}

 

 实体类 

 

NewsDto
 
 

 

package com.entity;

@EntityPK(PK = "newsId",defaultColumn = false,tableName = "NEWS")
public class NewsDto implements IBaseDto{

	private Integer newsId;

	private String title;

	private String brief;

	public Integer getNewsId() {
		return newsId;
	}

	public void setNewsId(Integer newsId) {
		this.newsId = newsId;
	}

	public String getTitle() {
		return title;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	public String getBrief() {
		return brief;
	}

	public void setBrief(String brief) {
		this.brief = brief;
	}

	@Override
	public String toString() {
		return "NewsDto [newsId=" + newsId + ", title=" + title + ", brief=" + brief + "]";
	}
	
	

}

 

 

IBaseDto
 

 

package com.entity;

public interface IBaseDto {

}

 

 KeyVO 

 

 

在组装过程中，用到健值对对象。
 

package DynamicSql;

public class KeyVO
{
  private String key;
  private Object value;

  public String getKey()
  {
    return this.key;
  }

  public void setKey(String key) {
    this.key = key;
  }

  public Object getValue() {
    return this.value;
  }

  public void setValue(Object value) {
    this.value = value;
  }
}
 

 注解类 

作用：注解类对实体对象进行标注，在dao开始时，传入实体对象。在持久化或查询过程中，我们通过该实现对象的的注解类进行解析获取到传入的参数，同时组装出动态的sql。
 


 EntityPK
 
 

 

package com.entity;


import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;


@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface EntityPK {
	
	String PK();
	
	boolean defaultColumn() default true;
	
	String tableName();
}
 

 

 


                

        

        

    




    

      

        

            

              
                
                  hsgao_water
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    1
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    4
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                  2
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
mybatisPlus的sqlSessionTemplate批量修改（与mybatis道理一致）

				
			

			

				

					weixin_45502734的博客
				

				

					03-16
					
					3620
					
				

			

		

		

			
				
一、简单步骤解析

①引入SqlSessionTemplate，mapper接口

②根据需求写一个更新数据的批量处理方法（关掉自动提交，批次commit）

③将需要修改的数据对象list，传入批处理方法中处理（实际相当于传一个update的where条件内容）

④调用接口进行数据更新

⑤测试+日志+数据展示



二、代码模块示例

①引入SqlSessionTemplate，mapper接口


    @Autowired
    private SqlSessionTemplate sqlSe

			
		

	



                

              
                



	

		

			

				
					
【方向盘】MyBatis基础知识33问（详解面试题）

				
			

			

				

					架构师：通透，才能写出好代码！
				

				

					08-24
					
					2465
					
				

			

		

		

			
				
MyBatis面试题33题

			
		

	



                


  
              

                


	

		

			

				
					
MyBatis源码解析——动态SQL实现原理_mybatis注解动态sql provider(2)

					
最新发布

				
			

			

				

					2401_84436058的博客
				

				

					04-28
					
					610
					
				

			

		

		

			
				
如上面的代码所示，StaticSqlSource类的内容比较简单，只封装了Mapper解析后的SQL内容和Mapper参数映射信息。

			
		

	





	

		

			

				
					
Ibatis中SqlMapClientTemplate和SqlMapClient的区别

					
热门推荐

				
			

			

				

					学习笔记
				

				

					11-25
					
					2万+
					
				

			

		

		

			
				
SqlMapClientTemplate是org.springframework.orm.ibatis下的
而SqlMapClient是ibatis的

SqlMapClientTemplate是SqlMapClient的封装类. 
SqlMapClient中包含着session的管理. 
SqlMapClientTemplate用于session的封装,以及异常的捕捉. 
所以按照以

			
		

	



		

			
		



	

		

			

				
					
全栈开发面试笔记【7】------------MyBatis底层原理及调优单元

				
			

			

				

					m0_45442261的博客
				

				

					09-25
					
					430
					
				

			

		

		

			
				
1、什么是 MyBatis？
答：MyBatis 是一个可以自定义 SQL、存储过程和高级映射的持久层框架。
2、讲下 MyBatis 的缓存
答：MyBatis 的缓存分为一级缓存和二级缓存,一级缓存放在 session 里面,默认就有,二级缓
存放在它的命名空间里,默认是不打开的,使用二级缓存属性类需要实现 Serializable 序列化
接口(可用来保存对象的状态),可在它的映射文件中配置
3、Mybatis 是如何进行分页的？分页插件的原理是什么？
答：
1）Mybatis 使用 RowBound

			
		

	





	

		

			

				
					
ibatis学习（二）--ibatis使用介绍

				
			

			

				

					咖啡妆
				

				

					12-07
					
					256
					
				

			

		

		

			
				
 
SqlMapClient对象

这个对象是iBatis操作数据库的接口（执行CRUD等操作），它也可以执行事务管理等操作。这个类是我们使用iBATIS的最主要的类。它是线程安全的。通常，将它定义为单例。（与hibernate中sessionFactory的定义类似）。如：


            import java.io.Reader;
            import com.i...

			
		

	





	

		

			

				
					
Spring Boot整合mybatis使用注解实现动态Sql、参数传递等常用操作(实现方法)

				
			

			

				

					09-07
				

			

		

		

			
				
本文主要讲解如何使用注解实现动态SQL和参数传递等常见功能。  首先，Spring Boot与Mybatis的整合通常通过添加相关依赖、配置Mybatis的配置文件（如`application.yml`或`application.properties`）以及创建Mapper...

			
		

	





	

		

			

				
					
mybatis动态sqlmybatis动态sqlmybatis动态sql

				
			

			

				

					04-28
				

			

		

		

			
				
其中，动态SQL是MyBatis的一个重要特性，它允许用户根据不同的条件拼接SQL语句，从而实现更加灵活和可扩展的数据库操作。  在MyBatis中，动态SQL使用的主要方式是通过使用XML或注解来编写SQL语句。下面我将简单介绍...

			
		

	





	

		

			

				
					
MyBatis 执行动态 SQL语句详解

				
			

			

				

					09-01
				

			

		

		

			
				
在 MyBatis 中，动态 SQL 是一个强大的特性，允许我们在 XML 映射文件或注解中编写条件语句，根据运行时的参数来决定 SQL 的具体执行内容。下面我们将深入探讨如何在 MyBatis 中执行动态 SQL 语句。  首先，我们要...

			
		

	





	

		

			

				
					
mybatis 动态sql及参数传递

				
			

			

				

					12-14
				

			

		

		

			
				
在实际开发过程中，我们往往需要编写复杂的SQL语句,拼接稍有不注意就会导致错误，Mybatis给开发者提供了动态SQL，大大降低了拼接SQL导致的错误。 动态标签  if标签 if标签通常用那个胡where语句,update语句,insert...

			
		

	





	

		

			

				
					
MyBatis注解配置映射器：动态SQL的实现

				
			

			

				

					08-22
				

			

		

		

			
				
总结来说，MyBatis注解配置提供了一种简洁的SQL映射方式，而动态SQL功能则极大地增强了查询的灵活性。在开发过程中，熟练掌握这两点，可以提升开发效率，同时使代码更加易于理解和维护。通过实践项目"MyBatisPro12...

			
		

	





	

		

			

				
					
Mybaits第四阶段---MyBatis的注解配置sql语句与参数传递

				
			

			

				

					DKPT的博客
				

				

					04-08
					
					1371
					
				

			

		

		

			
				
参数传递是指如何将mapper接口方法中的参数传递给sql语句的占位符. 简单点说,就是 #{} 里应该写啥。需求：现在要根据用户名查询用户对象。编写一个模块，使用注解去配置方法的sql语句。

			
		

	





	

		

			

				
					
2021-08-04

				
			

			

				

					MatchaAha的博客
				

				

					08-04
					
					111
					
				

			

		

		

			
				
Mybtis 框架的使用与提升01

官方文档：https://mybatis.org/mybatis-3/zh/index.html
mybatis plus

1.1 引入依赖
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis

			
		

	





	

		

			

				
					
MyBatis：常用的注解

				
			

			

				

					m0_52331159的博客
				

				

					03-08
					
					2529
					
				

			

		

		

			
				
【代码】MyBatis：常用的注释。

			
		

	





	

		

			

				
					
ibatis迁移mybatis详细方案（含脚本和注意事项）

				
			

			

				

					程序媛想事儿
				

				

					10-23
					
					1万+
					
				

			

		

		

			
				
小小的声明：该文章已优先发在阿里内网博客ibatis已成过去式，官方早已不再维护，使用ibatis的老应用迁移到mybatis很有必要，且好用的服务层框架springboot集成了mybatis，支持维护良好，更加说明了迁移到mybatis的重要性，下面详细说明整个迁移流程1.使用 ibatis到mybatis的map文件转换工具转换工具：ibatis2mybatis 
可以帮你将ibatis 2.

			
		

	





	

		

			

				
					
mybatis注解方式写入复杂sql

				
			

			

				

					zebbyte的博客
				

				

					10-21
					
					2420
					
				

			

		

		

			
				
mybatis是持久层框架，用于简化JDBC,具体就不作复述了。
这里重点阐述下mybatis注解的方式对比传统jdbc完成复杂sql编写。
注解方式是mybatis的独有的，关键的几个@Select @Insert @Delete@Update都是ibatis下的，如@Select

注解的方式极大地简化了sql的编写过程，如在接口文件里

对比JDBC标签写法

会发现能省去id,和resultMap的配置，代码也易读性也增强了不少。
接下来我要介绍下面各种情况的sql写法，
1.首先是基础sql，如上

			
		

	





	

		

			

				
					
mybatis实体类注解_SpringBoot2.x系列教程43--整合使用Mybatis

				
			

			

				

					weixin_39524425的博客
				

				

					12-18
					
					762
					
				

			

		

		

			
				
SpringBoot2.x系列教程43--整合使用Mybatis作者：一一哥在上一节中，我带大家学习了Spring Boot中整合JPA，那接下来这一章节中，我继续带领大家学习如何在Spring Boot中整合Mybatis。一. Mybatis简介1. MyBatis概述MyBatis是一款优秀的持久层框架，它本来是apache的一个开源项目iBatis。在2010年的时候，这个项目由apach...

			
		

	





	

		

			

				
					
Mybatise-plus实体类常用注解总结 @JsonFormat @TableField @TableId

				
			

			

				

					weixin_43850343的博客
				

				

					03-18
					
					4897
					
				

			

		

		

			
				
Mybatise_plus实体类常用注解总结@JsonFormat @TableField 

			
		

	





	

		

			

				
					
mybatis注解开发动态sql

				
			

			

				

					09-13
				

			

		

		

			
				
MyBatis注解开发动态SQL可以通过使用MyBatis的注解来生成动态SQL语句。下面是一些常用的注解和示例：

1. @SelectProvider：用于动态生成SELECT语句的注解。可以根据方法的参数动态生成不同的查询条件。

示例：
```java
@SelectProvider(type = UserSqlProvider.class, method = "getUserById")
User getUserById(Long id);
```

2. @InsertProvider：用于动态生成INSERT语句的注解。可以根据对象的属性动态生成插入语句。

示例：
```java
@InsertProvider(type = UserSqlProvider.class, method = "insertUser")
void insertUser(User user);
```

3. @UpdateProvider：用于动态生成UPDATE语句的注解。可以根据对象的属性动态生成更新语句。

示例：
```java
@UpdateProvider(type = UserSqlProvider.class, method = "updateUser")
void updateUser(User user);
```

4. @DeleteProvider：用于动态生成DELETE语句的注解。可以根据方法的参数动态生成删除条件。

示例：
```java
@DeleteProvider(type = UserSqlProvider.class, method = "deleteUserById")
void deleteUserById(Long id);
```

在使用上述注解时，需要提供一个对应的SQL提供者类（如上面示例中的UserSqlProvider），该类中定义了对应的SQL语句生成逻辑。

希望以上信息能对你有所帮助！如果你有其他问题，请继续提问。

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		
评论 2

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值