JAVA调用天气代码示例
前沿：最近在开发任务中需要获取每日的实时天气和天气预报，要求还是免费的。在网络上搜索了一下免费的API并有了以下思路
免费API网址：https://dev.qweather.com/docs/api/grid-weather/grid-weather-now/
- 调用格林天气API域名和正常的不同
- 需要注册账号需要得到key
- 上限：2000条/每日
配置文件
weather:
# 缓存时间【分钟】
ttl: 30
# 地区
area: 北京
# 格点天气配置
gedian-url: https://devapi.qweather.com
gedian-location: xxxx # 地区编码号
gedian-key: xxxxxx
配置实体类
@ConfigurationProperties(
prefix = "weather",
ignoreUnknownFields = true // 排除未匹配字段
)
@Component
@Data
@ToString
public class WeatherProperties {
private Integer ttl;
private String area;
private String gedianUrl;
private String gedianLocation;
private String gedianKey;
}
API结果返回类
没有提供所有的返回类
@Data
public class NowData {
/**
* 数据观测时间
*/
@JsonProperty("obsTime")
private String obsTime;
/**
* 温度，默认单位：摄氏度
*/
@JsonProperty("temp")
private String temp;
/**
* 天气状况的图标代码
*/
@JsonProperty("icon")
private String icon;
/**
* 天气状况的文字描述
*/
@JsonProperty("text")
private String text;
/**
* 风向360角度
*/
@JsonProperty("wind360")
private String wind360;
/**
* 风向
*/
@JsonProperty("windDir")
private String windDir;
/**
* 风力等级
*/
@JsonProperty("windScale")
private String windScale;
/**
* 风速，公里/小时
*/
@JsonProperty("windSpeed")
private String windSpeed;
/**
* 相对湿度，百分比数值
*/
@JsonProperty("humidity")
private String humidity;
/**
* 当前小时累计降水量
*/
@JsonProperty("precip")
private String precip;
/**
* 大气压强
*/
@JsonProperty("pressure")
private String pressure;
/**
* 云量，百分比数值。可能为空
*/
@JsonProperty("cloud")
private String cloud;
/**
* 露点温度。可能为空
*/
@JsonProperty("dew")
private String dew;
/**
* 最高气温
*/
private String maxTemp;
/**
* 最低气温
*/
private String minTemp;
/**
* 地区
*/
private String area;
}
远程调用接口
需要在启动类上加@EnableFeignClients
@FeignClient(name = "weather", url = "${weather.gedian-url}")
public interface WeatherFeign {
/**
* 格点获取实时天气
*
* @param location 地区编码
* @param key 请求key
* @return 实时天气
*/
@GetMapping("/v7/weather/now")
WeatherNow getWeatherNow(@RequestParam("location") String location, @RequestParam("key") String key);
/**
* 格点获取3日天气预报
*
* @param location 地区编码
* @param key 请求key
* @return 3日天气预报
*/
@GetMapping("/v7/weather/3d")
WeatherForecast getWeatherDay3(@RequestParam("location") String location, @RequestParam("key") String key);
/**
* 格点获取当天生活指数
*
* @param location 地区编码
* @param key 用户认证key
* @param type 生活指数的类型ID
* @return json
*/
@GetMapping("/v7/indices/1d")
Map<String, Object> getDailyLivingIndex(@RequestParam("location") String location, @RequestParam("key") String key, @RequestParam("type") String type);
}
控制层处理
其中的Redis工具类
@RestController
@RequestMapping("/weather")
public class WeatherController {
@Resource
private WeatherFeign weather;
@Resource
private WeatherProperties weatherProperties;
/**
* 获取实时天气
*/
@SaIgnore
@GetMapping("/getInfo")
public WeatherNow getInfo() {
String key = CacheConstants.WEATHER + "getInfo";
// 获取缓存对象
WeatherNow weatherCache = RedisUtils.getCacheObject(key);
if (Objects.isNull(weatherCache)) {
// 获取天气
weatherCache = getWeather();
// 缓存有效期30分钟
RedisUtils.setCacheObject(key, weatherCache);
RedisUtils.expire(key, Duration.ofMinutes(weatherProperties.getTtl()));
}
return weatherCache;
}
/**
* 获取天气
*
* @return 天气返回类
*/
private WeatherNow getWeather() {
// 远程调用 -> 实时天气
WeatherNow weatherNow = weather.getWeatherNow(weatherProperties.getGedianLocation(), weatherProperties.getGedianKey());
if (!StringUtils.equals(weatherNow.getCode(), String.valueOf(HttpStatus.SUCCESS))) {
// 返回空对象
return null;
} else {
// 地区名称
weatherNow.getNow().setArea(weatherProperties.getArea());
// 远程调用 -> 天气预报
getForecast(weatherNow.getNow());
return weatherNow;
}
}
/**
* 获取天气预报
* 最高温度,最低温度
*
* @param nowData 天气返回类
*/
private void getForecast(NowData nowData) {
WeatherForecast weatherDay3 = weather.getWeatherDay3(weatherProperties.getGedianLocation(), weatherProperties.getGedianKey());
List<WeatherForecast.DailyWeatherData> dailyList = weatherDay3.getDaily();
if (CollectionUtil.isNotEmpty(dailyList)) {
// 获取当天日期
LocalDate currentDate = LocalDate.now();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
String formattedDate = currentDate.format(formatter);
// 3日天气预报 -筛选> 当天最高温度,最低温度
Optional<WeatherForecast.DailyWeatherData> first = dailyList.stream()
.filter(f -> StringUtils.equals(formattedDate, f.getFxDate())).findFirst();
if (first.isPresent()) {
nowData.setMaxTemp(first.get().getTempMax());
nowData.setMinTemp(first.get().getTempMin());
}
}
}
/**
* 格点获取当天生活指数
*
* @return map
*/
@SaIgnore
@GetMapping("/getDailyLivingIndex")
public Map<String, Object> getDailyLivingIndex() {
//缓存key
String key = CacheConstants.WEATHER + "getDailyLivingIndex";
//获取缓存
Map<String, Object> resDailyLivingIndex = RedisUtils.getCacheObject(key);
//查询缓存是否存在
if (CollectionUtil.isEmpty(resDailyLivingIndex)) {
resDailyLivingIndex = weather.getDailyLivingIndex(weatherProperties.getGedianLocation(), weatherProperties.getGedianKey(), "0");
// 缓存有效期1天
if (resDailyLivingIndex != null && !resDailyLivingIndex.isEmpty()) {
RedisUtils.setCacheObject(key, resDailyLivingIndex, Duration.ofDays(1));
}
}
return resDailyLivingIndex;
}
/**
* 获取3日天气预报
*/
@SaIgnore
@GetMapping("/getWeatherDay3")
public WeatherForecast getWeatherDay3() {
String key = CacheConstants.WEATHER + "getWeatherDay3";
// 获取缓存对象
WeatherForecast weatherCache = RedisUtils.getCacheObject(key);
if (Objects.isNull(weatherCache)) {
// 获取天气
weatherCache = weather.getWeatherDay3(weatherProperties.getGedianLocation(), weatherProperties.getGedianKey());
// 缓存有效期30分钟
RedisUtils.setCacheObject(key, weatherCache);
RedisUtils.expire(key, Duration.ofDays(1));
}
return weatherCache;
}
}
Redis工具类
@NoArgsConstructor(access = AccessLevel.PRIVATE)
@SuppressWarnings(value = {"unchecked", "rawtypes"})
public class RedisUtils {
private static final RedissonClient CLIENT = SpringUtils.getBean(RedissonClient.class);
/**
* 限流
*
* @param key 限流key
* @param rateType 限流类型
* @param rate 速率
* @param rateInterval 速率间隔
* @return -1 表示失败
*/
public static long rateLimiter(String key, RateType rateType, int rate, int rateInterval) {
RRateLimiter rateLimiter = CLIENT.getRateLimiter(key);
rateLimiter.trySetRate(rateType, rate, rateInterval, RateIntervalUnit.SECONDS);
if (rateLimiter.tryAcquire()) {
return rateLimiter.availablePermits();
} else {
return -1L;
}
}
/**
* 获取客户端实例
*/
public static RedissonClient getClient() {
return CLIENT;
}
/**
* 发布通道消息
*
* @param channelKey 通道key
* @param msg 发送数据
* @param consumer 自定义处理
*/
public static <T> void publish(String channelKey, T msg, Consumer<T> consumer) {
RTopic topic = CLIENT.getTopic(channelKey);
topic.publish(msg);
consumer.accept(msg);
}
public static <T> void publish(String channelKey, T msg) {
RTopic topic = CLIENT.getTopic(channelKey);
topic.publish(msg);
}
/**
* 订阅通道接收消息
*
* @param channelKey 通道key
* @param clazz 消息类型
* @param consumer 自定义处理
*/
public static <T> void subscribe(String channelKey, Class<T> clazz, Consumer<T> consumer) {
RTopic topic = CLIENT.getTopic(channelKey);
topic.addListener(clazz, (channel, msg) -> consumer.accept(msg));
}
/**
* 缓存基本的对象，Integer、String、实体类等
*
* @param key 缓存的键值
* @param value 缓存的值
*/
public static <T> void setCacheObject(final String key, final T value) {
setCacheObject(key, value, false);
}
/**
* 缓存基本的对象，保留当前对象 TTL 有效期
*
* @param key 缓存的键值
* @param value 缓存的值
* @param isSaveTtl 是否保留TTL有效期(例如: set之前ttl剩余90 set之后还是为90)
* @since Redis 6.X 以上使用 setAndKeepTTL 兼容 5.X 方案
*/
public static <T> void setCacheObject(final String key, final T value, final boolean isSaveTtl) {
RBucket<T> bucket = CLIENT.getBucket(key);
if (isSaveTtl) {
try {
bucket.setAndKeepTTL(value);
} catch (Exception e) {
long timeToLive = bucket.remainTimeToLive();
setCacheObject(key, value, Duration.ofMillis(timeToLive));
}
} else {
bucket.set(value);
}
}
/**
* 缓存基本的对象，Integer、String、实体类等
*
* @param key 缓存的键值
* @param value 缓存的值
* @param duration 时间
*/
public static <T> void setCacheObject(final String key, final T value, final Duration duration) {
RBatch batch = CLIENT.createBatch();
RBucketAsync<T> bucket = batch.getBucket(key);
bucket.setAsync(value);
bucket.expireAsync(duration);
batch.execute();
}
/**
* 如果不存在则设置 并返回 true 如果存在则返回 false
*
* @param key 缓存的键值
* @param value 缓存的值
* @return set成功或失败
*/
public static <T> boolean setObjectIfAbsent(final String key, final T value, final Duration duration) {
RBucket<T> bucket = CLIENT.getBucket(key);
return bucket.setIfAbsent(value, duration);
}
/**
* 注册对象监听器
* <p>
* key 监听器需开启 `notify-keyspace-events` 等 redis 相关配置
*
* @param key 缓存的键值
* @param listener 监听器配置
*/
public static <T> void addObjectListener(final String key, final ObjectListener listener) {
RBucket<T> result = CLIENT.getBucket(key);
result.addListener(listener);
}
/**
* 设置有效时间
*
* @param key Redis键
* @param timeout 超时时间
* @return true=设置成功；false=设置失败
*/
public static boolean expire(final String key, final long timeout) {
return expire(key, Duration.ofSeconds(timeout));
}
/**
* 设置有效时间
*
* @param key Redis键
* @param duration 超时时间
* @return true=设置成功；false=设置失败
*/
public static boolean expire(final String key, final Duration duration) {
RBucket rBucket = CLIENT.getBucket(key);
return rBucket.expire(duration);
}
/**
* 获得缓存的基本对象。
*
* @param key 缓存键值
* @return 缓存键值对应的数据
*/
public static <T> T getCacheObject(final String key) {
RBucket<T> rBucket = CLIENT.getBucket(key);
return rBucket.get();
}
/**
* 获得key剩余存活时间
*
* @param key 缓存键值
* @return 剩余存活时间
*/
public static <T> long getTimeToLive(final String key) {
RBucket<T> rBucket = CLIENT.getBucket(key);
return rBucket.remainTimeToLive();
}
/**
* 删除单个对象
*
* @param key 缓存的键值
*/
public static boolean deleteObject(final String key) {
return CLIENT.getBucket(key).delete();
}
/**
* 删除集合对象
*
* @param collection 多个对象
*/
public static void deleteObject(final Collection collection) {
RBatch batch = CLIENT.createBatch();
collection.forEach(t -> {
batch.getBucket(t.toString()).deleteAsync();
});
batch.execute();
}
/**
* 检查缓存对象是否存在
*
* @param key 缓存的键值
*/
public static boolean isExistsObject(final String key) {
return CLIENT.getBucket(key).isExists();
}
/**
* 缓存List数据
*
* @param key 缓存的键值
* @param dataList 待缓存的List数据
* @return 缓存的对象
*/
public static <T> boolean setCacheList(final String key, final List<T> dataList) {
RList<T> rList = CLIENT.getList(key);
return rList.addAll(dataList);
}
/**
* 注册List监听器
* <p>
* key 监听器需开启 `notify-keyspace-events` 等 redis 相关配置
*
* @param key 缓存的键值
* @param listener 监听器配置
*/
public static <T> void addListListener(final String key, final ObjectListener listener) {
RList<T> rList = CLIENT.getList(key);
rList.addListener(listener);
}
/**
* 获得缓存的list对象
*
* @param key 缓存的键值
* @return 缓存键值对应的数据
*/
public static <T> List<T> getCacheList(final String key) {
RList<T> rList = CLIENT.getList(key);
return rList.readAll();
}
/**
* 缓存Set
*
* @param key 缓存键值
* @param dataSet 缓存的数据
* @return 缓存数据的对象
*/
public static <T> boolean setCacheSet(final String key, final Set<T> dataSet) {
RSet<T> rSet = CLIENT.getSet(key);
return rSet.addAll(dataSet);
}
/**
* 注册Set监听器
* <p>
* key 监听器需开启 `notify-keyspace-events` 等 redis 相关配置
*
* @param key 缓存的键值
* @param listener 监听器配置
*/
public static <T> void addSetListener(final String key, final ObjectListener listener) {
RSet<T> rSet = CLIENT.getSet(key);
rSet.addListener(listener);
}
/**
* 获得缓存的set
*
* @param key 缓存的key
* @return set对象
*/
public static <T> Set<T> getCacheSet(final String key) {
RSet<T> rSet = CLIENT.getSet(key);
return rSet.readAll();
}
/**
* 缓存Map
*
* @param key 缓存的键值
* @param dataMap 缓存的数据
*/
public static <T> void setCacheMap(final String key, final Map<String, T> dataMap) {
if (dataMap != null) {
RMap<String, T> rMap = CLIENT.getMap(key);
rMap.putAll(dataMap);
}
}
/**
* 注册Map监听器
* <p>
* key 监听器需开启 `notify-keyspace-events` 等 redis 相关配置
*
* @param key 缓存的键值
* @param listener 监听器配置
*/
public static <T> void addMapListener(final String key, final ObjectListener listener) {
RMap<String, T> rMap = CLIENT.getMap(key);
rMap.addListener(listener);
}
/**
* 获得缓存的Map
*
* @param key 缓存的键值
* @return map对象
*/
public static <T> Map<String, T> getCacheMap(final String key) {
RMap<String, T> rMap = CLIENT.getMap(key);
return rMap.getAll(rMap.keySet());
}
/**
* 获得缓存Map的key列表
*
* @param key 缓存的键值
* @return key列表
*/
public static <T> Set<String> getCacheMapKeySet(final String key) {
RMap<String, T> rMap = CLIENT.getMap(key);
return rMap.keySet();
}
/**
* 往Hash中存入数据
*
* @param key Redis键
* @param hKey Hash键
* @param value 值
*/
public static <T> void setCacheMapValue(final String key, final String hKey, final T value) {
RMap<String, T> rMap = CLIENT.getMap(key);
rMap.put(hKey, value);
}
/**
* 获取Hash中的数据
*
* @param key Redis键
* @param hKey Hash键
* @return Hash中的对象
*/
public static <T> T getCacheMapValue(final String key, final String hKey) {
RMap<String, T> rMap = CLIENT.getMap(key);
return rMap.get(hKey);
}
/**
* 删除Hash中的数据
*
* @param key Redis键
* @param hKey Hash键
* @return Hash中的对象
*/
public static <T> T delCacheMapValue(final String key, final String hKey) {
RMap<String, T> rMap = CLIENT.getMap(key);
return rMap.remove(hKey);
}
/**
* 删除Hash中的数据
*
* @param key Redis键
* @param hKeys Hash键
*/
public static <T> void delMultiCacheMapValue(final String key, final Set<String> hKeys) {
RBatch batch = CLIENT.createBatch();
RMapAsync<String, T> rMap = batch.getMap(key);
for (String hKey : hKeys) {
rMap.removeAsync(hKey);
}
batch.execute();
}
/**
* 获取多个Hash中的数据
*
* @param key Redis键
* @param hKeys Hash键集合
* @return Hash对象集合
*/
public static <K, V> Map<K, V> getMultiCacheMapValue(final String key, final Set<K> hKeys) {
RMap<K, V> rMap = CLIENT.getMap(key);
return rMap.getAll(hKeys);
}
/**
* 设置原子值
*
* @param key Redis键
* @param value 值
*/
public static void setAtomicValue(String key, long value) {
RAtomicLong atomic = CLIENT.getAtomicLong(key);
atomic.set(value);
}
/**
* 获取原子值
*
* @param key Redis键
* @return 当前值
*/
public static long getAtomicValue(String key) {
RAtomicLong atomic = CLIENT.getAtomicLong(key);
return atomic.get();
}
/**
* 递增原子值
*
* @param key Redis键
* @return 当前值
*/
public static long incrAtomicValue(String key) {
RAtomicLong atomic = CLIENT.getAtomicLong(key);
return atomic.incrementAndGet();
}
/**
* 递减原子值
*
* @param key Redis键
* @return 当前值
*/
public static long decrAtomicValue(String key) {
RAtomicLong atomic = CLIENT.getAtomicLong(key);
return atomic.decrementAndGet();
}
/**
* 获得缓存的基本对象列表
*
* @param pattern 字符串前缀
* @return 对象列表
*/
public static Collection<String> keys(final String pattern) {
Stream<String> stream = CLIENT.getKeys().getKeysStreamByPattern(pattern);
return stream.collect(Collectors.toList());
}
/**
* 删除缓存的基本对象列表
*
* @param pattern 字符串前缀
*/
public static void deleteKeys(final String pattern) {
CLIENT.getKeys().deleteByPattern(pattern);
}
/**
* 检查redis中是否存在key
*
* @param key 键
*/
public static Boolean hasKey(String key) {
RKeys rKeys = CLIENT.getKeys();
return rKeys.countExists(key) > 0;
}
}
maven
<!--feign客户端依赖-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
<version>3.1.3</version> <!-- 或者根据相应版本选择合适的OpenFeign版本 -->
</dependency>
().getKeysStreamByPattern(pattern);
return stream.collect(Collectors.toList());
}
/**
* 删除缓存的基本对象列表
*
* @param pattern 字符串前缀
*/
public static void deleteKeys(final String pattern) {
CLIENT.getKeys().deleteByPattern(pattern);
}
/**
* 检查redis中是否存在key
*
* @param key 键
*/
public static Boolean hasKey(String key) {
RKeys rKeys = CLIENT.getKeys();
return rKeys.countExists(key) > 0;
}
}
maven
<!--feign客户端依赖-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
<version>3.1.3</version> <!-- 或者根据相应版本选择合适的OpenFeign版本 -->
</dependency>
