Heim  >  Artikel  >  Java  >  Detaillierte Erläuterung der SSM-Integration mit Redis in Java

Detaillierte Erläuterung der SSM-Integration mit Redis in Java

黄舟
黄舟Original
2017-09-30 10:31:553505Durchsuche

Detaillierte Erläuterung der SSM-Integration mit Redis in Java

Redis-Installation und -Nutzung

Der erste Schritt ist natürlich die Installation von Redis. Hier nehmen wir die Installation unter Windows als Beispiel.

  • Laden Sie zunächst Redis herunter. Sie können zwischen der MSI- oder ZIP-Paketinstallationsmethode wählen.

  • Zip-Methode muss das cmd-Fenster öffnen und im ausführen Dekomprimiertes Verzeichnis redis-server redis.windows.confRedis starten

  • Redis startet standardmäßig nach der Installation im MSI-Modus, es ist keine Konfiguration erforderlich

  • Kann in redis. Ändern Sie die Redis-Portnummer, das Passwort und andere Konfigurationen in der Datei „windows.conf“. Nachdem die Änderung abgeschlossen ist, verwenden Sie den Befehl zum Neustart redis-server redis.windows.conf

  • Führen Sie

    im Redis-Installationsverzeichnis aus, um die Redis-Betriebsoberfläche zu öffnen. redis-cli -h 127.0.0.1 -p 6379 -a 密码

  • Wenn ein Fehler gemeldet wird

    , verwenden Sie (error) ERR operation not permitted, um auth 密码

  • zu überprüfen

SSM integriert Redis

Hier werden wir Redis direkt basierend auf der Framework-Integration von SSM im vorherigen Artikel integrieren.

Hier ist zu beachten, dass die Pojo-Klasse in gespeichert ist Redis muss die SchnittstelleSerializable implementieren.

pom.xml konfigurieren, um Redis-Abhängigkeiten einzuführen


<!--redis--><dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
    <version>1.6.1.RELEASE</version></dependency><dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.7.3</version></dependency>

redis.properties

redis.host=127.0.0.1
redis.port=6379
redis.password=redis
redis.maxIdle=100
redis.maxWait=1000
redis.testOnBorrow=true
redis.timeout=100000
defaultCacheExpireTime=3600

applicationContext-redis.xml


<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"       
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"       
xmlns:mvc="http://www.springframework.org/schema/mvc"       
xmlns:context="http://www.springframework.org/schema/context"       
xmlns:aop="http://www.springframework.org/schema/aop"       
xmlns:tx="http://www.springframework.org/schema/tx"       
xsi:schemaLocation="http://www.springframework.org/schema/beans        
http://www.springframework.org/schema/beans/spring-beans.xsd        
http://www.springframework.org/schema/mvc        
http://www.springframework.org/schema/mvc/spring-mvc.xsd        
http://www.springframework.org/schema/context        
http://www.springframework.org/schema/context/spring-context.xsd        
http://www.springframework.org/schema/aop        
http://www.springframework.org/schema/aop/spring-aop.xsd        
http://www.springframework.org/schema/tx        
http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--引入Redis配置文件-->
    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>classpath:redis.properties</value>
            </list>
        </property>
    </bean>

    <!-- jedis 连接池配置 -->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxIdle" value="${redis.maxIdle}"/>
        <property name="maxWaitMillis" value="${redis.maxWait}"/>
        <property name="testOnBorrow" value="${redis.testOnBorrow}"/>
    </bean>
    <!-- redis连接工厂 -->
    <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <property name="poolConfig" ref="poolConfig"/>
        <property name="port" value="${redis.port}"/>
        <property name="hostName" value="${redis.host}"/>
        <property name="password" value="${redis.password}"/>
        <property name="timeout" value="${redis.timeout}"></property>
    </bean>
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="connectionFactory"/>
        <property name="keySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="valueSerializer">
            <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
        </property>
    </bean>
    <!-- 缓存拦截器配置 -->
    <bean id="methodCacheInterceptor" class="com.zkh.interceptor.MethodCacheInterceptor">
        <property name="redisUtil" ref="redisUtil"/>
        <property name="defaultCacheExpireTime" value="${defaultCacheExpireTime}"/>
        <!-- 禁用缓存的类名列表 -->
        <property name="targetNamesList">
            <list>
                <value></value>
            </list>
        </property>
        <!-- 禁用缓存的方法名列表 -->
        <property name="methodNamesList">
            <list>
                <value></value>
            </list>
        </property>
    </bean>
    <bean id="redisUtil" class="com.zkh.util.RedisUtil">
        <property name="redisTemplate" ref="redisTemplate"/>
    </bean>
    <!--配置切面拦截方法 -->
    <aop:config proxy-target-class="true">
        <aop:pointcut id="controllerMethodPointcut" expression="        
        execution(* com.zkh.service.impl.*.select*(..))"/>
        <aop:advisor advice-ref="methodCacheInterceptor" pointcut-ref="controllerMethodPointcut"/>
    </aop:config></beans>

MethodCacheInterceptor.java


package com.zkh.interceptor;
import com.zkh.util.RedisUtil;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import java.util.List;
/** 
* Redis缓存过滤器 
*/
public class MethodCacheInterceptor implements MethodInterceptor {    
private RedisUtil redisUtil;    
private List<String> targetNamesList; // 禁用缓存的类名列表
    private List<String> methodNamesList; // 禁用缓存的方法列表
    private String defaultCacheExpireTime; // 缓存默认的过期时间

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        Object value = null;

        String targetName = invocation.getThis().getClass().getName();
        String methodName = invocation.getMethod().getName();        
        if (!isAddCache(targetName, methodName)) {            
        // 跳过缓存返回结果
            return invocation.proceed();
        }
        Object[] arguments = invocation.getArguments();
        String key = getCacheKey(targetName, methodName, arguments);        
        try {            // 判断是否有缓存
            if (redisUtil.exists(key)) {                
            return redisUtil.get(key);
            }            // 写入缓存
            value = invocation.proceed();            
            if (value != null) {                
            final String tkey = key;                
            final Object tvalue = value;                
            new Thread(new Runnable() {                    
            @Override
                    public void run() {
                        redisUtil.set(tkey, tvalue, Long.parseLong(defaultCacheExpireTime));
                    }
                }).start();
            }
        } catch (Exception e) {
            e.printStackTrace();            
            if (value == null) {                
            return invocation.proceed();
            }
        }        return value;
    }    
    /**     
    * 是否加入缓存     
    *     
    * @return     
    */
    private boolean isAddCache(String targetName, String methodName) {        
    boolean flag = true;        
    if (targetNamesList.contains(targetName)
                || methodNamesList.contains(methodName) || targetName.contains("$$EnhancerBySpringCGLIB$$")) {
            flag = false;
        }        return flag;
    }    
    /**     
    
    * 创建缓存key     
    *     
    * @param targetName     
    
   * @param methodName     
   * @param arguments    
    */
    private String getCacheKey(String targetName, String methodName,
                               Object[] arguments) {
        StringBuffer sbu = new StringBuffer();
        sbu.append(targetName).append("_").append(methodName);        
        
        if ((arguments != null) && (arguments.length != 0)) {           
         for (int i = 0; i < arguments.length; i++) {
                sbu.append("_").append(arguments[i]);
            }
        }        return sbu.toString();
    }    public void setRedisUtil(RedisUtil redisUtil) {        
    this.redisUtil = redisUtil;
    }    public void setTargetNamesList(List<String> targetNamesList) {        
    this.targetNamesList = targetNamesList;
    }    public void setMethodNamesList(List<String> methodNamesList) {        
    this.methodNamesList = methodNamesList;
    }    public void setDefaultCacheExpireTime(String defaultCacheExpireTime) {        
    
    this.defaultCacheExpireTime = defaultCacheExpireTime;
    }
}

RedisUtil.java-Toolklasse

package com.zkh.util;import org.apache.log4j.Logger;import org.springframework.data.redis.core.RedisTemplate;import org.springframework.data.redis.core.ValueOperations;import java.io.Serializable;import java.util.Set;import java.util.concurrent.TimeUnit;/** * Redis工具类 */public class RedisUtil {    private RedisTemplate<Serializable, Object> redisTemplate;    /**     * 批量删除对应的value     *     * @param keys     */
    public void remove(final String... keys) {        for (String key : keys) {            remove(key);
        }
    }    /**     * 批量删除key     *     * @param pattern     */
    public void removePattern(final String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);        if (keys.size() > 0)
            redisTemplate.delete(keys);
    }    /**     * 删除对应的value     *     * @param key     */
    public void remove(final String key) {        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }    /**     * 判断缓存中是否有对应的value     *     * @param key     * @return     */
    public boolean exists(final String key) {        return redisTemplate.hasKey(key);
    }    /**     * 读取缓存     *     * @param key     * @return     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate
                .opsForValue();
        result = operations.get(key);        return result;
    }    /**     * 写入缓存     *     * @param key     * @param value     * @return     */
    public boolean set(final String key, Object value) {        boolean result = false;        try {
            ValueOperations<Serializable, Object> operations = redisTemplate
                    .opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }        return result;
    }    /**     * 写入缓存     *     * @param key     * @param value     * @return     */
    public boolean set(final String key, Object value, Long expireTime) {        boolean result = false;        try {
            ValueOperations<Serializable, Object> operations = redisTemplate
                    .opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }        return result;
    }    public void setRedisTemplate(
            RedisTemplate<Serializable, Object> redisTemplate) {        this.redisTemplate = redisTemplate;
    }
}


Effektanzeige

Detaillierte Erläuterung der SSM-Integration mit Redis in Java

Zuerst gibt es keine Datensätze in Redis. Besuchen Sie dann die erste Seite mit Datensätzen

Detaillierte Erläuterung der SSM-Integration mit Redis in Java

Überprüfen Sie den Cache erneut und die Datensätze wurden als Redis gespeichert, und beim ersten Besuch werden Daten von MySQL gelesen

Detaillierte Erläuterung der SSM-Integration mit Redis in Java

Detaillierte Erläuterung der SSM-Integration mit Redis in Java

Drücken Sie

, um die Seite zu aktualisieren und von Tomcat aus steuern. Sie können sehen, dass keine SQL-Abfrage erfolgt, sondern die zwischengespeicherten Daten direkt von Redis gelesen werden, was die Belastung der Datenbank verringert F5

Detaillierte Erläuterung der SSM-Integration mit Redis in Java

Detaillierte Erläuterung der SSM-Integration mit Redis in Java

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der SSM-Integration mit Redis in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Stellungnahme:
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn