Créez votre propre FW de persistance (Java)

Si vous utilisez pleinement le moteur de modèle, N'est-il pas facile de créer un FW persistant qui contient SQL dans un fichier externe, tel que MyBatis ou Doma? J'ai pensé et j'ai réussi.

Vous pouvez maintenant obtenir les données pour ʻuser_mst` avec juste le code suivant.

selectById.sql

select *
from user_mst
where id = {{ p.bind(id) }}

user_Code Java pour obtenir mst

SqlTemplate sqlTemplate = new SqlTemplate();
DbAccess dbAccess = new DbAccess(connection);//java.sql.Lien

Map<String, Object> context = new HashMap<>();
context.put("id", id);
QueryBuilder query = sqlTemplate.evaluate( "selectById.sql", context);
UserMst userMst = dbAccess.selectOne( query, UserMst.class );

Cette fois, le moteur de modèle utilise Pebble. Mais je pense que vous pouvez probablement le faire avec ʻApache Velocity, FreeMarker ou Mustache.java`. Je pense que vous pouvez utiliser votre moteur de template préféré. Le fait est que vous pouvez appeler la méthode dans le modèle. Travailler directement avec JDBC est fastidieux, utilisez donc Apache Commons DBUtils. La valeur est définie automatiquement en utilisant pleinement la réflexion.

build.groovy

// https://mvnrepository.com/artifact/com.mitchellbosecke/pebble
compile group: 'com.mitchellbosecke', name: 'pebble', version: '2.4.0'
// https://mvnrepository.com/artifact/commons-dbutils/commons-dbutils
compile group: 'commons-dbutils', name: 'commons-dbutils', version: '1.7'

Moteur de modèle pour SQL

/**Moteur de modèle pour SQL*/
import com.mitchellbosecke.pebble.PebbleEngine;
import com.mitchellbosecke.pebble.template.PebbleTemplate;
import java.io.StringWriter;

public class SqlTemplate{
	private static PebbleEngine engine;
	/**Obtenez le moteur de modèle*/
	private PebbleEngine getEngine(){
		if( null == engine){
			engine = new PebbleEngine.Builder()
					.autoEscaping(false)//html escape est superflu, alors supprimez-le
					.strictVariables(true)//Paramètre qui déclenche une exception lorsque vous essayez d'utiliser une variable qui n'est pas en contexte
					.build();
		}
		return engine;
	}

	/**Obtenir une requête basée sur le nom du modèle SQL et la valeur du modèle*/
	public QueryBuilder evaluate(String templateFileName, Map<String, Object> context) throws Exception{
		SqlParametors sqlParametors = new SqlParametors();
		context.put( "p", sqlParametors );
		String result = simpleEvaluateTemplate(templateFileName, context );
		QueryBuilder query = new QueryBuilder( result, sqlParametors.getParams() );
		return query;
	}

	/**Une méthode qui évalue simplement le modèle et renvoie la chaîne résultante*/
	private String simpleEvaluateTemplate(String templateFileName, Map<String, Object> context) throws Exception{
		StringWriter writer = new StringWriter();
		PebbleTemplate template = getEngine().getTemplate(templateFileName);
		template.evaluate(writer, context);
		return writer.toString();
	}
}

paramètre sql

import java.util.List;

/**Classe de stockage des paramètres SQL.Accès dans le moteur de modèle.*/
public class SqlParametors {
	/**paramètre*/
	private List<Object> params = new ArrayList<>();
	/**Lier les paramètres*/
	public String bind(Object param){
		params.add(param);
		return "?";
	}
	/**Obtenir les paramètres*/
	public List<Object> getParams(){
		return params;
	}
}

Classe de stockage des requêtes

import java.util.List;
import java.util.Arrays;

/**Classe de stockage des requêtes*/
public class QueryBuilder {
	/**instruction SQL*/
	private StringBuilder sql = new StringBuilder();
	/**paramètre*/
	private List<Object> params = new ArrayList<>();

	public QueryBuilder(){
	}

	public QueryBuilder(CharSequence sql, List<Object>params){
		this.sql.append(sql);
		this.params.addAll(params);
	}

	public StringBuilder getSql() {
		return sql;
	}

	public void setSql(CharSequence sql) {
		this.sql = new StringBuilder( sql.toString() );
	}

	public Object[] getParams() {
		return params.toArray();
	}

	public void setParams(Object[] params) {
		this.params = Arrays.asList(params);
	}


}

Accès à la base de données

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.ResultSetHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

/**Classe d'accès DB. Opération de base de données avec un objet QueryBuilder comme argument*/
class DbAccess{
	/**Exécution de la requête(dbutils) */
	private QueryRunner queryRunner = new QueryRunner();

	/**lien*/
	private java.sql.Connection conn;

	/**constructeur*/
	public DbAccess(java.sql.Connection conn){
		this.conn = conn;
	}

	/**Pour insérer et mettre à jour des déclarations*/
	public int update(QueryBuilder query ) throws Exception{
		int rows = queryRunner.update(conn, query.getSql().toString(), query.getParams() );
		return rows;
	}

	/**Pour quand vous voulez sélectionner et obtenir le résultat dans une liste*/
	public <T> List<T>  selectList(QueryBuilder query, Class<T> clazz) throws Exception{
		ResultSetHandler<List<Map<String, Object>>> h = new MapListHandler();
		List<Map<String, Object>> mapList = queryRunner.query(conn, query.getSql().toString(), h, query.getParams() );
		List<T> beanList = convMapList2BeanList(mapList, clazz);
		return beanList;
	}

	/**Pour quand vous voulez sélectionner et obtenir le résultat une seule ligne*/
	public <T> T selectOne(QueryBuilder query, Class<T> clazz) throws Exception{
		ResultSetHandler<Map<String, Object>> h = new MapHandler();
		Map<String, Object> map = queryRunner.query(conn, query.getSql().toString(), h ,query.getParams());
		if( null == map )
			return null;
		T bean = convMap2Bean(map, clazz );
		return bean;
	}

	/**Pour lorsque vous souhaitez sélectionner et obtenir une seule colonne du résultat*/
	public <T> T selectOneColumn(QueryBuilder query, Class<T> clazz) throws Exception{
		Object value = queryRunner.query(conn, query.getSql().toString(), new ScalarHandler<T>(), query.getParams() );
		return clazz.cast(value);
	}
	
	/**
	 *Définir la liste d'objets de la carte sur la liste de Bean.
	 * @param mapList Liste des objets Map
	 * @param clazz Définir la classe Bean de destination
	 * @throws Exception
	 */
	private <T> List<T> convMapList2BeanList(List<Map<String, Object>> mapList, Class<T> clazz) throws Exception{
		List<T> list = new ArrayList<>();
		for( int i = 0; i < mapList.size(); i++ ){
			list.add( convMap2Bean(mapList.get(i), clazz) );
		}
		return list;
	}

	/**
	 *Définir l'objet Map sur Bean.
	 * @objet de carte de param map
	 * @param clazz Définir la classe Bean de destination
	 * @throws Exception
	 */
	private <T> T convMap2Bean(Map<String, ?> map, Class<T> clazz) throws Exception{
		T bean = clazz.newInstance();
		//Obtenir la liste des champs
		Field[] fields = clazz.getDeclaredFields();

		for( Field f : fields ){
			f.setAccessible(true);
			f.set(bean, map.get(f.getName()) );//TODO Snake Case => Vous pouvez mettre dans le processus de conversion en chameau.
		}
		return bean;
	}
}