数据库
首页 > 数据库> > SpEL、Spring缓存注解、Redis核心配置类、微服务Eureka

SpEL、Spring缓存注解、Redis核心配置类、微服务Eureka

作者:互联网

SpEL表达式

什么是SpEL表达式

SpEL(Spring Expression Language),即Spring表达式语言。它是一种类似JSP的EL表达式、但又比后者更为强大有用的表达式语言。

为什么要用SpEL

因为它可以在spring容器内实时查询和操作数据,尤其是操作List列表型、Array数组型数据。所以使用SpEL可以有效缩减代码量,优化代码结构。

用法

1. @Value注解

@Value可以加在class的成员变量和形参上。用法如下:

    //@Value能修饰成员变量和方法形参
    //#{}内就是SpEL表达式的语法
    //Spring会根据SpEL表达式语法,为变量arg赋值
    @Value("#{表达式}")
    public String arg;

如果修饰成员变量,Spring容器会根据SpEL表达式语法筛选修改数据,然后赋值给所@Value修饰的变量;

如果修饰方法形参,则是过滤传进来的参数值。

PS:value属性的表现形式

@Value()的value属性可以有三种表现形式:

@Value("hello")
private String word;    //将"hello"字符串赋值给word变量
@Value("http://www.baidu.com")
private Resource url;    //从网址"http://www.baidu.com"获取资源

2.XML配置

......... 写的太多了我不想写了 ,大概了解了一下子,估计也挺少用到

原文链接: SpEL表达式的用法

spring关于缓存的注解使用@CacheConfig,@Cacheable,@CachePut,@CacheEvict,@Caching

/**
 *   @CacheConfig: 提供一种在类级别共享公共缓存相关设置的机制。
 *   这个注解写在类上,主要作用是抽取缓存方法的公共属性
 *  主要属性有:
 *   缓存名称:cacheNames,对应value或者cacheNames
 *   缓存管理器名称:cacheManager,对应cacheManager
 *   KeyGenerator的名称集合:keyGenerator,对应keyGenerator
 */
@CacheConfig(cacheNames = "student")  //
public interface StudentService { ... }
 /**
  *  @CachePut: 与@Cacheable基本相同
  *
  *  区别是
  * @CachePut:这个注释可以确保方法被执行,同时方法的返回值也被记录到缓存中。
  * @Cacheable:当重复使用相同参数调用方法时,方法本身不会被调用,而是直接从缓存中找到结果并返回。
  * 也就是说@Cacheable一次缓存,不再更新。@CachePut次次缓存,一直更新
  *
  */
 @CachePut(key = "#p0.sno")
 Student update(Student student);
/**
 *   @CacheEvict: 放置在方法上,可以按照条件清除缓存
 *
 *   主要属性有:
 * 键名:key,可以为空,可使用 SpEL 表达式编写,如果为空,则按照方法的所有参数进行组合
 * 缓存条件:condition,可以为空,使用 SpEL 编写,返回 true 或 false,为 true 才进行缓存
 * 缓存名称:value,可集体抽取为@CacheConfig的cacheNames,或者单独写,必填
 * 是否清空所有缓存:allEntries,缺省为 false,指定为 true
 */
@CacheEvict(key = "#p0", allEntries = true)
void deleteStudentBySno(String sno);
/**
 *   @Cacheable: 放置在方法上,表示可以将结果放入缓存
 *
 *   主要属性有:
 * 键名:key,可以为空,可使用 SpEL 表达式编写,如果为空,则按照方法的所有参数进行组合
 * 缓存条件:condition,可以为空,使用 SpEL 编写,返回 true 或 false,为 true 才进行缓存
 * 缓存名称:value,可集体抽取为@CacheConfig的cacheNames,或者单独写,必填
 */
@Cacheable(key = "#p0")
Student queryStudentBySno(String sno);
/**
 *  @Caching: 为自定义的组合缓存规则
 *
 *  主要属性有:
 * @Cacheable的组合:cacheable,默认{}
 * @CachePut的组合:put,默认{}
 * @CacheEvict的组合:evict,默认{}
 */
@Caching
void caching(String aa);

Redis核心配置类

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * Created by xinchen on 2022/7/22
 *
 * @Description : Redis的核心配置类
 */
@Configuration
public class RedisConfig {

    // 自己定义了一个RedisTemplate
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        // 我们为了自己开发方便,一般直接使用 <String, Object>
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);
        // Json序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // String 的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }

}

微服务

微服务的架构特征:

微服务的上述特性其实是在给分布式架构制定一个标准,进一步降低服务之间的耦合度,提供服务的独立性和灵活性。做到高内聚,低耦合。

因此,可以认为微服务是一种经过良好架构设计的分布式架构方案

微服务的架构特征总结

服务拆分原则

微服务远程调用

原因:微服务之间数据库不互通,但服务间有关联,必须在一方服务请求时向另一服务发送请求

方式:使用RestTemplate发起http请求实现远程调用

流程:

  1. 先向Spring注入RestTemplate
@SpringBootApplication
public class OrderApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderApplication.class, args);
    }
    /**
     * 创建RestTemplate并注入Spring
     * @param
     * @return
     */
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }

}
  1. 修改OrderService
@Service
public class OrderService {

    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private RestTemplate restTemplate;

    public Order queryOrderById(Long orderId) {
        // 1.查询订单
        Order order = orderMapper.findById(orderId);
        // 2.利用RestTemplate发送http请求,查询用户
        String url = "http://localhost:8081/user/" + order.getUserId();
        // get请求:getForObject(url, *.class); 得到想要的值类型*
        User user = restTemplate.getForObject(url, User.class);
        // 3.封装User对象到Order
        order.setUser(user);
        // 4.返回
        return order;
    }
}

这样就可以完成在一方服务请求时向另一服务发送请求的功能

服务调用关系

Eureka注册中心

作用

问题1:order-service如何得知user-service实例地址?

获取地址信息的流程如下:

问题2:order-service如何从多个user-service实例中选择具体的实例?

问题3:order-service如何得知某个user-service实例是否依然健康,是不是已经宕机?

注意:一个微服务,既可以是服务提供者,又可以是服务消费者,因此eureka将服务注册、服务发现等功能统一封装到了eureka-client端

Eureka中的微服务角色类型:

搭建EurekaServer

<!--eureka服务端依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
server:
  port: 10086
spring:
  application:  # eureka的服务名称
    name: eurekaserver
eureka:
  client:
    service-url:  # eureka的地址信息
      defaultZone: http://127.0.0.1:10086/eureka/

Eureka服务注册(以order服务为例)

<!--eureka客户端依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
spring:
  application:  # eureka的服务名称
    name: orderservice
eureka:
  client:
    service-url:  # eureka的地址信息
      defaultZone: http://127.0.0.1:10086/eureka/

无论是消费者还是提供者,引入eureka-client依赖、知道eureka地址后,都可以完成服务注册

启动多个order-service 实例

标签:缓存,服务,service,Spring,Redis,eureka,SpEL,Eureka,order
来源: https://www.cnblogs.com/XinChennn/p/16542350.html