Capítulo 1 Análise de requisitos
Está planejado adicionar redis para implementar o processamento de cache no projeto de código aberto da equipe. Como as funções comerciais foram implementadas em parte, escrevendo as classes de ferramentas Redis e, em seguida, se referindo a elas, a quantidade de alterações é grande e a dissociação não pode ser alcançada, então pensei na AOP (programação orientada para a seção) da estrutura da mola.
Projeto de código aberto: https://github.com/u014427391/jeepatform
Capítulo 2 Introdução ao Springboot
Como uma importante estrutura de código aberto no campo da estrutura Javaee, a Spring Framework desempenha um papel importante no desenvolvimento de aplicativos corporativos. Ao mesmo tempo, a estrutura da primavera e seus sub -quadros são muito, então a quantidade de conhecimento é muito ampla.
Springboot: um sub -quadro da estrutura da mola, também chamado de Microframework, é uma estrutura lançada em 2014 que facilita o desenvolvimento da estrutura da primavera. Depois de aprender todo o conhecimento das estruturas da primavera, as estruturas da primavera exigem inevitavelmente muito XML. Se você usar estruturas de troca, poderá usar o desenvolvimento da anotação para simplificar bastante o desenvolvimento com base nas estruturas de primavera. O Springboot faz pleno uso do modo de configuração do Javaconfig e o conceito de "Convenção é melhor que a configuração", que pode simplificar bastante o desenvolvimento de aplicativos da Web e serviços de repouso com base no SpringMVC.
Capítulo 3 Introdução a Redis
3.1 Redis Instalação e implantação (Linux)
Para instalação e implantação do Redis, consulte meu blog (Redis é escrito com base em C, então instale o compilador GCC antes da instalação): //www.vevb.com/article/79096.htm
3.2 Introdução ao Redis
Redis agora se tornou um dos bancos de dados de memória mais populares na comunidade de desenvolvimento da Web. Com o rápido desenvolvimento do Web2.0 e o aumento da proporção de dados semiestruturados, os sites têm cada vez mais demandas por desempenho eficiente.
Além disso, sites grandes geralmente têm centenas ou mais servidores Redis. Como um sistema poderoso, o Redis tem seu próprio uso, seja no sistema de armazenamento, fila ou cache.
Para começar com o Springboot Framework, consulte o artigo anterior: http://www.vevb.com/article/111197.htm
Capítulo 4 Implementação de cache de Redis
4.1 O seguinte diagrama de estrutura
Diagrama da estrutura do projeto:
4.2 Configuração do arquivo YML do Springboot
Adicione o recurso Application.yml abaixo do recurso, onde MySQL, Druid e Redis estão configurados principalmente
Spring: DataSource: # Main Data Source Shop: URL: JDBC: MySQL: //127.0.0.1: 3306/jeepAtform? AUTORECONNECT = trueNicode = True & CaracterenCoding = UTF8 & CaracterSultsults = utf8 & usessl = Falsename: root: raiz-climt: utf8 e caracteressults = utf8 & usessl = falsename: root: root: rootngn: rootmcrinf8 e caracteres. com.alibaba.druid.pool.DruidDataSource # Connection pool settings druid: initial-size: 5 min-idle: 5 max-active: 20 # Configure the time to get the connection waiting timeout max-wait: 60000 # Configure how long it takes to perform a detection interval to detect idle connections that need to be closed, in millisecond time-between-eviction-runs-millis: 60000 # Configure o tempo mínimo para sobreviver na piscina, em milissegundos Min-Evictable-Idle-Millis: 300000 # Oracle Por favor, use selecione 1 de Dual Validação-Query: Selecione 'X' Testat-While-Idle: TRUE TEST-O-AMPRAR: MAX-POOL PREPARADO ESTATION-PER-CONNEÇÃO Size: 20 # Configure filtros para monitorar estatísticas interceptando. Após a remoção da interface de monitoramento, o SQL não pode ser contado, 'Wall' é usado para filtros de firewall: Stat, Wall, Slf4J # Open Mergesql Função através da propriedade ConnectProperties; slow SQL records connection-properties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000 # Merge monitoring data of multiple DruidDataSource use-global-data-source-stat: true jpa: database: mysql hibernate: show_sql: true format_sql: true ddl-auto: none Nomeação: estratégia física: org.hibernate.boot.model.naming.physicalnamingstrategyStandardImpl mvc: view: prefixo:/web-inf/jsp/sufixo: .jsp #jedis Configuration: pool: host: 127.0.0.1. Maxwaitmillis: 100000
Escreva uma classe de configuração para iniciar a configuração jedisconfig.java:
pacote org.muses.jeepatform.config; importar org.springframework.beans.factory.annotation.autowired; importar org.springframework.beans.factory.annotation.qualifier; Org.springframework.boot.autoconfigure.condition.conditionalonMissingBean; importar org.springframework.boot.context.properties.configurationProperties; import org.springframeworkwork.NeAnxToT.AnTation.Beanation; redis.clients.jedis.jedispool; importar redis.clients.jedis.jedispoolconfig; @configuration //@configurationproperties (prefix = jedisconfig.jedis_prefix) classe pública "jedisconfig {// public static string final jedis_prefix)" @Bean(name= "jedisPool") @Autowired public JedisPool jedisPool(@Qualifier("jedisPoolConfig") JedisPoolConfig config, @Value("${spring.jedis.pool.host}")String host, @Value("${spring.jedis.pool.port}")int port, @Value ("$ {spring.jedis.pool.timeout}") int timeout, @value ("$ {spring.jedis.pool.password}") string senha) {retorna new jedispool (config, host, port, timeout, senha); } @Bean (name = "JedispoolConfig") public jedispoolconfig jedispoolConfig (@Value ("$ {spring.jedis.pool.config.maxtotal}") int maxtotal, @value ("$ {spring.jedis.pool.config.Maxidle,") @Value ("$ {spring.jedis.pool.config.maxwaitmillis}") int maxwaitmillis) {jedispoolconfig config = new jedispoolConfig (); config.setmaxtotal (maxtotal); config.setmaxidle (maxidle); config.setmaxwaitmillis (maxwaitmillis); return config; }}4.3 Escrita da aula de meta-anulação
Escreva uma classe de meta -anotação rediscache.java. Todas as classes definidas pela anotação modificada são implementadas automaticamente no processamento de cache da AOP.
pacote org.muses.jeepatform.annotation; importar org.muses.jeepatform.common.rediscachenamespace; importar java.lang.annotation.*;/***meta -alvo (elementTyPeSethod) para identificar o método usado para consultar o database*/@documentado@alvo (elegTtypeSpeSpe.method) {// Rediscachenamespace namespace ();} Além da retenção, existem outras três anotações fornecidas pelo JDK 5, como alvo, herdadas e documentadas. Com base nisso, podemos implementar meta -anotações personalizadas
Definimos o Rediscache como referência com base no nível do método.
1.RetentionPolicy.Source Este tipo de anotações é reservado apenas no nível do código -fonte e será ignorado durante a compilação.
2. RetentionPolicy.Class Este tipo de anotações é retido durante a compilação e existe no arquivo de classe, mas a JVM o ignorará.
3. RetentionPolicy.untime Esse tipo de anotações será reservado pela JVM, para que possam ser lidas e usadas pela JVM ou outro código que usa mecanismos de reflexão em tempo de execução.
4.4 Chamando Jedispool para implementar o Processamento de Cache do Redis
package org.muses.jeepatform.cache; importar org.springframework.beans.factory.annotation.autowired; importar org.springframework.tereotype.comPONN; javax.annotation.resource; @Component ("Rediscache") Classe pública Rediscache {@AUTOWIRED PRIVADO JEDISPOOL JEDISPOOL; private Jedispool getjedispool () {return jedispool; } public void setjedispool (Jedispool Jedispool) {this.jedispool = Jedispool; } / ** * Obtenha dados do Redis cache * @param rediskey * @return * / public objeto getDataFromredis (string rediskey) {jedis jedis = jedispool.getResource (); byte [] bytearray = jedis.get (rediskey.getbytes ()); if (byteArray! = null) {return serializeutil.unserialize (bytearray); } retornar nulo; } / ** * Salvar dados para redis * @param rediskey * / public string savedatatoredis (string rediskey, object obj) {byte [] bytes = serializeutil.Serialize (obj); Jedis jedis = jedispool.getResource (); String code = jedis.set (rediskey.getbytes (), bytes); Código de retorno; }}Classe de ferramenta de serialização de objetos:
pacote org.muses.jeepatform.cache; importar java.io. BytearrayOutputStream baos = null; tente {baos = novo bytearrayoutputStream (); OOS = new ObjectOutputStream (Baos); OOS.WriteObject (OBJ); byte [] bytearray = baos.tobytearray (); retornar bytearray; } catch (ioexception e) {e.printStackTrace (); } retornar nulo; } / ** * Deserialize Object * @param byteArray * @return * / objeto estático público não reiniciam (byte [] bytearray) {bytearrayInputStream bais = null; tente {// Deserialize para objeto Bais = novo byteArrayInputStream (bytearray); ObjectInputStream ois = new ObjectInputStream (Bais); retornar oIS.readObject (); } catch (Exceção e) {e.printStackTrace (); } retornar nulo; }} Aqui me lembro que as classes VO devem implementar serializável
Por exemplo, informações do menu Vo classe, esta é uma aula de entidade de mapeamento JPA
package org.muses.jeepatform.core.entity.admin;import javax.persistence.*;import java.io.Serializable;import java.util.List;/** * @description Menu information entity* @author Nicky * @date March 17, 2017*/@Table(name="sys_menu")@Entitypublic class Menu implements Serializable { / ** ID do menu ** / private int menusId; / ** ID superior **/ private int parentid; / ** Nome do menu **/ String Private String Menuname; / ** Ícone de menu **/ String privada MENUCON; / ** URL do menu **/ String privada menuurl; / ** Tipo de menu **/ String private Menutype; / ** Classificação de menu **/ String privada MenuOrder; / ** Status do menu **/ String privada Menustatus; Lista privada <pune> submenu; destino de string privado; private booleano hassubmenu = false; public menu () {super (); } @Id @generatedValue (estratégia = generationType.Identity) public int getMenuid () {return this.menuid; } public void setMenuid (int menusId) {this.Menuid = MENUID; } @Column (length = 100) public int getParentId () {return parentid; } public void setParentId (int parentId) {this.parentId = parentid; } @Column (length = 100) public string getMenUname () {return this.menuname; } public void setMenUnuname (String Menuname) {this.menUname = Menuname; } @Column (length = 30) public string getMenuicon () {return this.menuicon; } public void SetMenuicon (String MENUCON) {this.Menuicon = MENUCON; } @Column (length = 100) public string getMenuurl () {return this.menuurl; } public void setMenuurl (String menuurl) {this.menuurl = menuurl; } @Column (length = 100) public string getMenutype () {return this.menutype; } public void setMenutype (string menutype) {this.menutype = Menutype; } @Column (length = 10) public string getMenuorder () {return menuOrder; } public void setMenuOrder (String menuOrder) {this.MenuOrder = MenuOrder; } @Column (length = 10) public string getMenustatus () {return Menustatus; } public void setMenustatus (String Menustatus) {this.menustatus = Menustatus; } @Transient Public List <Cune> getSubmenu () {return submenu; } public void setSubmenu (list <pune> submenu) {this.submenu = submenu; } public void Settarget (String Target) {this.target = Target; } @Transient public string getTarget () {return Target; } public void sethassubmenu (boolean hassubmenu) {this.hassubmenu = hassubmenu; } @Transient public boolean gethassubmenu () {return hassubmenu; }}4.5 Spring AOP implementa o cache do método que monitora todos anotados por @rediscache
Primeiro, receba o cache da Redis. Se você não puder consultar, consulte o banco de dados MySQL e salve -o no cache Redis. Da próxima vez que você consultar, ligue diretamente para o cache Redis.
pacote org.muses.jeepatform.cache; importar org.aspectj.lang.proecedingJoinpoint; importar org.aspectj.lang.annotation.around; importar org.aspectj.lang.annoTation.aspect; import.aspectj.lang.ergation.pointcut; importação ou org.slf4j.loggerfactory; importar org.springframework.beanS.factory.annotation.autowired; importar org.springframework.beans.factory.annotation.qualifier; Importing Redis Redis Redis ChesterCrolDent.TeReTypeTyE.Component;/*** aOp implementos estático final logger logger = LoggerFactory.getLogger (redisaspect.class); @Autowired @Qualifier ("Rediscache") Rediscache Private Rediscache; /*** Métodos para interceptar todas as metanotações Rediscache Anotações* /@PointCut (" @anotação (org.muses.jeepatform.annotation.rediscache)) public void PointCutMethod () {} /*** para processamento surround, primeiro obtenha o cache do redis. Se você não pode consultar, consulte o banco de dados do MySQL, * salve -o no cache redis * @param junção * @return */@around ("pointcutmethod ()") objeto público em torno (prosseguir o parâmetros de ponto de partida). String applid = null; Objeto [] args = jun juntpoint.getargs (); if (args! = null && args.length> 0) {applid = string.valueof (args [0]); } // Obtenha a classe em que o método de destino está localizado String Target = junçãoPoint.getTarget (). ToString ClassName = Target.split ("@") [0]; // Obtenha o nome do método do método de destino MethodName = junçãoPoint.getSignature (). GetName (); // Redis Key Format: Applid: Método Nome String RedisKey = Applid + ":" + ClassName + "." + MethodName; Objeto obj = rediscache.getDataFromredis (rediskey); if (obj! = null) {logger.info ("************ dados encontrados no redis ****************"); Logger.info ("Redis Key Value:"+Rediskey); Logger.info ("Redis Value Value:"+obj.toString ()); retornar obj; } long endtime = system.currenttimemillis (); Logger.info ("Redis Cache AOP Processing Time:"+(Endtime-startTime)); Logger.info ("*************** nenhum dado encontrado no redis ****************"); tente {obj = jun juntpoint.proeced (); } catch (throwable e) {e.printStackTrace (); } Logger.info ("*************** Comece a consultar dados de mysql ***************"); // pós-set: salve os dados encontrados no banco de dados no código da string redis = redisCache.sAvedatatorEdis (Rediskey, OBJ); if (code.equals ("ok")) {Logger.info ("************ Os dados foram salvos com sucesso no Redis Cache !!! ************"); Logger.info ("Redis Key Value:"+Rediskey); Logger.info ("Redis Value Value:"+obj.toString ()); } retornar obj; }}Em seguida, ligue para @RediscAche para implementar o cache
/ ** * Obtenha as informações do menu através do Menu ID * @param ID * @return */ @transaction @rediscache public menu FindMenubyId (@RedisCAcheKey int id) {return menurepository.findmenubyMenuid (id); }Os métodos que efetuam login no sistema e depois adicionam a anotação @rediscache implementarão o Processamento de Cache do Redis
Você pode ver que Redis é salvo para armazenar em cache
Código do projeto: https://github.com/u014427391/jeepatform
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.