Escritura a mano mybatis framework: aumento de la función de caché y transacciones

Cache com.simple.ibatis.cache
cache interface-Cache
copia el código
public interface Cache {

/**放入缓存*/
void putCache(String key,Object val);

/**获取缓存*/
Object getCache(String key);

/**清空缓存*/
void cleanCache();

/**获取缓存健数量*/
int getSize();

/**移除key的缓存*/
void removeCache(String key);

}
Copiar código
La interfaz de caché del marco personalizado proporciona funciones básicas de adición, eliminación, modificación y verificación.

Cache implementación básica class-SimpleCache
copiar código
public class SimpleCache implementa Cache { // Internamente usa HashMap como caché para lograr el mapa estático privado <String, Object> map = new HashMap <> (); // Llamar al método map.put () para lograr almacenamiento Función de caché @Override public void putCache (String key, Object val) { map.put (key, val); } // Llamar al método map.get () para realizar la función de caché @Override public Object getCache (String key) { return map .get (key); } // llamar al método map.clear () para realizar la función de borrar el caché @Override public void cleanCache () { map.clear (); } // llamar al método map.size () para obtener el número de caché @Override public int getSize () { return map.size (); }

// Llamar al método map.remove () para eliminar la caché
@Override
public void removeCache (String key) { map.remove (key); } } copiar el código simple-ibatis completa la encapsulación de HasaMap y realiza la adquisición y eliminación básica de la caché , Clear y otras funciones.

Con estrategia de eliminación de LRU:
código de copia de LruCache
/ **

@autor xiabing
@description: Clase de empaquetado de caché, con función de estrategia de eliminación de Lru
* /
clase pública LruCache implementa Cache { // Número de caché predeterminado private static Integer cacheSize = 100; // Factor de carga private static Float loadFactory = 0.75F; // Real cache private Cache trueCache; // Anula el método LinkedHashMap para implementar la función Lru private Map <String, Object> linkedCache; // El elemento de caché que se eliminará private static Map.Entry removeEntry;

public LruCache (Cache trueCache) { esto (cacheSize, loadFactory, trueCache); }

public LruCache (Integer cacheSize, Float loadFactory, Cache trueCache) { this.cacheSize = cacheSize; this.loadFactory = loadFactory; this.trueCache = trueCache; this.linkedCache = new LinkedHashMap <String, Object> (cacheSize, loadFactory, true) { @Override // Cuando el número de cachés es mayor que el número de caché predeterminado establecido, linkedHashMap eliminará el elemento utilizado menos recientemente, obtendrá este elemento y lo eliminará en el caché real. Protected boolean removeEldestEntry (Map.Entry eldest) { if (getSize () > cacheSize) { removeEntry = eldest; return true; } return false; } }; }

@Override
public void putCache (String key, Object val) { this.trueCache.putCache (key, val); this.linkedCache.put (key, val); if (removeEntry! = Null) { // Si el último encontrado Elemento, elimínelo removeCache ((String) removeEntry.getKey ()); removeEntry = null; } }

@Override
public Object getCache (String key) { // El significado de la adquisición de linkedCache es desencadenar la clasificación de elementos de linkedHashMap linkedCache.get (clave); return trueCache.getCache (clave); }

@Override
public void cleanCache () { trueCache.cleanCache (); LinkedCache.clear (); }

@Override
public int getSize () { return trueCache.getSize (); }

@Override
public void removeCache (String key) { trueCache.removeCache (key); } } Copiar código LruCache se implementa de acuerdo con las características de LinkedHashMap. Si tiene alguna pregunta al respecto, consulte mybatis sobre la implementación de la función LruCache-introducción a mybatis cache

Prueba de código de proyecto
Copiar código
@Test
// Probar adquisición de caché
public void shouldGetCache () throws SQLException { // Inicializar grupo de conexiones PoolDataSource poolDataSource = new PoolDataSource ("com.mysql.jdbc.Driver", "jdbc: mysql: //101.132. 150.75: 3306 / our-auth "," root "," root "); Config config = new Config (" com / simple / ibatis / mapper ", poolDataSource); // Establecer configuración global, abrir caché config.setOpenCache (true ); // Obtener Ejecutor simpleExecutor = config.getExecutor (); UserMapper userMapper = simpleExecutor.getMapper (UserMapper.class);

    User user = new User();
    user.setId(1);
    user.setName("root");
   // 第一次调用
    List<User> userList = userMapper.getUsers(user);
    // 第二次调用，我在源码中有打印输出，若使用了缓存，则打印语句
    List<User> userList1 = userMapper.getUsers(user);
    
    simpleExecutor.close();
}

Copia el código y el
resultado se imprime ya que es caché. Si estás interesado, puedes probarlo tú mismo

Configuré el caché globalmente para que sea configurable, y LruCache se genera de forma predeterminada. Y actualice la caché a la fuerza antes de actualizar, modificar y eliminar operaciones SQL. Para obtener una lógica de código detallada, consulte la clase SimpleExecutor en el proyecto.

Función de
transacción com.simple.ibatis.transaction interfaz de transacción-
Código de copia de transacción
/ **

@Autor xiabing
@Desc Agregar función de transacción
** /
public interface Transaction { / * Obtener enlace / Conexión getConnection () lanza SQLException; / * Enviar / void commit () lanza SQLException; / * Rollback / void rollback () lanza SQLException; / * Cerrar / void close () lanza SQLException; } Copiar código JDBC transacción-SimpleTransaction copiar código paquete com.simple.ibatis.transaction;

import com.simple.ibatis.datasource.PoolDataSource;

import java.sql.Connection;
import java.sql.SQLException;

/ **

@Autor xiabing
@Desc implementación simple de transacción
** /
clase pública SimpleTransaction implementa Transaction {

Conexión de conexión privada; // Conexión de base de datos
Private PoolDataSource dataSource; // Fuente de datos
private Integer level = Connection.TRANSACTION_REPEATABLE_READ ;; // Nivel de aislamiento de transacciones
private Boolean autoCommmit = true; // Si enviar automáticamente

public SimpleTransaction (PoolDataSource dataSource) { this (dataSource, nulo, nulo); }

public SimpleTransaction (fuente de datos PoolDataSource, nivel entero, autoCommmit booleano) { this.dataSource = dataSource; if (nivel! = nulo) { este.nivel = nivel; } if (autoCommmit! = null) { this.autoCommmit = autoCommmit; } }

@Override
public Connection getConnection () lanza SQLException { this.connection = dataSource.getConnection ();
```
 this.connection.setAutoCommit(autoCommmit);

 this.connection.setTransactionIsolation(level);

 return this.connection;
```
}

@Override
public void commit () lanza SQLException { if (this.connection! = Null ) { this.connection.commit (); } }

@Override
public void rollback () lanza SQLException { if (this.connection! = Null ) { this.connection.rollback (); } }

/ * Antes de cerrar el enlace, si el envío automático se establece en falso, debe realizar una operación de reversión /
@Override
public void close () lanza SQLException { if (! AutoCommmit && connection! = Null) { connection.rollback (); } / * poner de nuevo en el grupo / IF (conexión = nulo!) { dataSource.removeConnection (conexión); } / * enlace se establece en nulo / this.connection = null; } } copiar el código simpleTransaction principales capacidades de gestión de transacciones en la base de datos misma (Es decir, conexión), el nivel de aislamiento de transacciones es el nivel de aislamiento de transacciones de mysql por defecto. Mediante la gestión de Connection, se realiza el control de transacciones de una serie de operaciones en conexión.

Copie el código
Prueba
public void shouldOpenTransaction () { / * Configuración básica / PoolDataSource poolDataSource = new PoolDataSource ("com.mysql.jdbc.Driver", "jdbc: mysql: //101.132.150.75: 3306 / our-auth", "root "," Root "); Config config = new Config (" com / simple / ibatis / mapper ", poolDataSource); / * Establecer para habilitar la transacción y cerrar la confirmación automática / config.setOpenTransaction (true);

    /**获取执行器*/
    Executor simpleExecutor = config.getExecutor();
    UserMapper userMapper = simpleExecutor.getMapper(UserMapper.class);

    User user = new User();
    user.setId(1);
    user.setName("xiabing");
    /**更新名字为xiabing，但未提交*/
    userMapper.update(user);

    User user1 = userMapper.getUserById(1);
    /**获取ID为1的名字，为root，说明上文的语句还没有提交*/
    System.out.println(user1.getName());
    /**事务提交语句*/
    //simpleExecutor.commit();
}
龙华大道1号http://www.kinghill.cn/LongHuaDaDao1Hao/index.html

Escritura a mano mybatis framework: aumento de la función de caché y transacciones

Supongo que te gusta