Spring高级技术应用——百战商城实现(下)

时间静止不是简史

发布于 2020-07-27 11:33:12

1.1K0

发布于 2020-07-27 11:33:12

文章被收录于专栏：Java探索之路 Java探索之路Java探索之路

六、开发百战商城前台系统

基于Solr的搜索服务的数据导入

环境搭建

安装Solr与中文分词器 Solr与中文分词器的安装
指定需要被搜索字段例如:item_title, item_sell_point等, 以便我们能通过这些字段下的关键词来进行搜索

			 <!-- type:类型,text_ik代表使用中分词器
   		      indexed:是否参与索引,true:是
			  stored:是否进行数据返回/回显,true:是
			  item_keywords:父作用域,会将其下面子作用域进行扫描,提高读取速度,但是需要注意的是必须要指定上面的作用域-->
	<field name="item_title" type="text_ik" indexed="true" stored="true"/>
	<field name="item_sell_point" type="text_ik" indexed="true" stored="true"/>
	<field name="item_price" type="long" indexed="true" stored="true"/>
	<field name="item_image" type="string" indexed="false" stored="true" />
	<field name="item_category_name" type="string" indexed="true" stored="true" />
	<field name="item_desc" type="text_ik" indexed="true" stored="false" />
	<field name="item_keywords" type="text_ik" indexed="true" stored="false" multiValued="true"/>
	
	<copyField source="item_title" dest="item_keywords"/>
	<copyField source="item_sell_point" dest="item_keywords"/>
	<copyField source="item_category_name" dest="item_keywords"/>
	<copyField source="item_desc" dest="item_keywords"/>

创建搜索项目 ,修改pom文件

需要用到pojo,但是我们可以通过依赖Mapper项目来简介添加Pojo项目

需要用到Spring Data整合Solr的坐标

<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>ah.szxy.project</groupId>
		<artifactId>bz_parent</artifactId>
		<version>0.0.1-SNAPSHOT</version>
	</parent>
	<artifactId>frontend_search</artifactId>

	<dependencies>
		<!-- mapper(include pojo) -->
		<dependency>
			<groupId>ah.szxy.project</groupId>
			<artifactId>common_mapper</artifactId>
			<version>0.0.1-SNAPSHOT</version>
		</dependency>
		<!-- untils -->
		<dependency>
			<groupId>ah.szxy.project</groupId>
			<artifactId>common_utils</artifactId>
			<version>0.0.1-SNAPSHOT</version>
		</dependency>

		<!--Spring Boot Web Starter -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<!--Spring Cloud Eureka Client Starter -->
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
		</dependency>
		<!--Spring Boot Data Solr Starter -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-solr</artifactId>
		</dependency>
		
	</dependencies>
	
	<!-- 打包插件,打成jar,用于在虚拟机中发布服务 -->
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

修改全局配置文件 application.yml 配置应用名,数据库连接参数,Solr的配置,端口号,注册中心服务端地址

spring:
  application:
    name: frontend-search
  datasource:
    driverClassName: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/bz_shop?useSSL=false
    username: root
    password: root
    type: com.alibaba.druid.pool.DruidDataSource   
  data:
    solr:
      host: http://192.168.179.138:8080/solr/
      core: collection1
      
server:
  port: 9900
  
eureka:       #配置Eureka服务注册中心地址
  client:
    serviceUrl:
      defaultZone: http://eureka-server:8761/eureka/

启动类

/**
 * 搜索服务的启动类
 * @author 曹海洋
 *
 */
@SpringBootApplication
@MapperScan("ah.szxy.mapper")
public class FrontendSearchApplication {
	
	public static void main(String[] args) {
		SpringApplication.run(FrontendSearchApplication.class, args);
	}
}

配置类

/**
* SolrTemplate 配置类
* 注意包
*/
@Configuration
public class SolrConfiguration {
	@Autowired
	private SolrClient solrClient;
	
	@Bean
	public SolrTemplate	 getSolrTemplate() {
		return new SolrTemplate(solrClient);
	}
}

数据库查询语句构建

1.设计查询语句( 查询到的结果用于导入Solr索引库中 )

数据库查询的参数是根据Solr中指定的字段来写的 ,因为Solr已经我们添加了 Id 这个字段,

所以这里没有配置Id 字段,但是数据库的查询语句中是有id这个字段的

查询语句的定义(多表连接查询)

select item.id,item.title,item.sell_point,item.price,item.image,cat.name,idesc.item_desc
from tb_item item
join tb_item_cat cat
on item.cid = cat.id
join tb_item_desc idesc
on item.id = idesc.item_id

查询结果

创建Mapper层和实体类因为使用的是逆向工程生成的查询方法 ,只能进行单表查询 , 如果需要使用多表连接查询需要我们自定义这些实体类,Mapper接口以及映射文件

/**
*实体类
 * item.id,item.title,item.sell_point,item.price,item.image,
 *  cat.name,idesc.item_desc
 *  
 * @author chy
 *
 */
public class SolrItem implements Serializable {
	private Long id;
	private String title;
	private String sell_point;
	private Long price;
	private String image;
	private String name;
	private String item_desc;
	public Long getId() {
		return id;
	}
	public void setId(Long id) {
		this.id = id;
	}
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	public String getSell_point() {
		return sell_point;
	}
	public void setSell_point(String sell_point) {
		this.sell_point = sell_point;
	}
	public Long getPrice() {
		return price;
	}
	public void setPrice(Long price) {
		this.price = price;
	}
	public String getImage() {
		return image;
	}
	public void setImage(String image) {
		this.image = image;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getItem_desc() {
		return item_desc;
	}
	public void setItem_desc(String item_desc) {
		this.item_desc = item_desc;
	}

}

Mapper接口

/**
 * 定义获取查询结果的接口
 * @author chy
 *
 */
public interface SolrItemMapper {
	List<SolrItem> getItemList();
}

映射文件注意: 这里执行的是查询操作, 在搜索的项目中执行插入的操作

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="ah.szxy.mapper.SolrItemMapper">

	<select id="getItemList" resultType="ah.szxy.pojo.SolrItem">
		select item.id,item.title,item.sell_point,item.price,item.image,cat.name,idesc.item_desc
		from tb_item item
		join tb_item_cat cat
		on item.cid = cat.id
		join tb_item_desc idesc
		on item.id = idesc.item_id
	</select>
</mapper>

将数据导入Solr

业务层接口返回值可以自定义,可以定义一个Interger类型 public interface SolrService { /** * 向Solr中导入数据 * @return */ Result importAll(); }
接口实现类 SolrItemMapper 注入Mapper接口,solrTemplate以及配置文件中的索引库的指定spring.data.solr.core 这样做的目的是防止硬编码

import org.apache.solr.common.SolrInputDocument;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.solr.core.SolrTemplate;
import org.springframework.stereotype.Service;

import ah.szxy.mapper.SolrItemMapper;
import ah.szxy.pojo.SolrItem;
import ah.szxy.utils.Result;

@Service
public class SolrServiceImpl implements SolrService {
	@Autowired
	private SolrItemMapper solrItemMapper;
	@Autowired
	private SolrTemplate solrTemplate;

	@Value("${spring.data.solr.core}")
	private String collection;

	@Override
	public Result importAll() {
		try {
			// 查询数据
			List<SolrItem> list = this.solrItemMapper.getItemList();
			// 将数据添加索引库中
			for (SolrItem item : list) {
				// 创建SolrInputDocument 对象
				SolrInputDocument document = new SolrInputDocument();
				document.setField("id", item.getId());
				document.setField("item_title", item.getTitle());
				document.setField("item_sell_point", item.getSell_point());
				document.setField("item_price", item.getPrice());
				document.setField("item_image", item.getImage());
				document.setField("item_category_name", item.getName());
				document.setField("item_desc", item.getItem_desc());
				// 写入索引库
				this.solrTemplate.saveDocument(this.collection, document);
			}
			this.solrTemplate.commit(this.collection);
			return Result.ok();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return Result.error("导入失败");
	}
}

controller

@RestController
@RequestMapping("/solr/search")
public class SolrController {
	@Autowired
	private SolrService solrService;
	
	@RequestMapping("/importAll")
	public Result importAll() {
		return this.solrService.importAll();
	}
}

4.启动项目

访问 :导入数据的这个方法,查看返回结果

访问 http://192.168.179.138:8080/solr/#/ ,没有导入数据前

导入数据后, 出现下面结果说明导入成功:

基于Solr的搜索服务的实现

接口文档

根据接口文档知,我们需要创建一个返回给前端页面的数据模型,包含下面的7条分页属性( 也是我们在Solr的配置文件中所配置的属性 )

/**
* Solr 返回给前端页面的数据模型
* 根据前端接口文档编写
*/
public class SolrDocument implements Serializable {
	private String id;
	private String item_title;
	private String item_sell_point;
	private String item_price;
	private String item_image;
	private String item_category_name;
	private String item_desc;
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getItem_title() {
		return item_title;
	}
	public void setItem_title(String item_title) {
		this.item_title = item_title;
	}
	public String getItem_sell_point() {
		return item_sell_point;
	}
	public void setItem_sell_point(String item_sell_point) {
		this.item_sell_point = item_sell_point;
	}
	public String getItem_price() {
		return item_price;
	}
	public void setItem_price(String item_price) {
		this.item_price = item_price;
	}
	public String getItem_image() {
		return item_image;
	}
	public void setItem_image(String item_image) {
		this.item_image = item_image;
	}
	public String getItem_category_name() {
		return item_category_name;
	}
	public void setItem_category_name(String item_category_name) {
		this.item_category_name = item_category_name;
	}
	public String getItem_desc() {
		return item_desc;
	}
	public void setItem_desc(String item_desc) {
		this.item_desc = item_desc;
	}
	
}

功能具体实现

1.接口类

在SpringData整合Solr定义的分页属性中page的类型就是Long而不是Integer

  /**
    * 首页搜索功能的实现
    * 
    * @param q 关键词
    * @param page 在SpringData整合Solr定义的page的类型就是Long而不是Integer
    * @param rows
    * @return
    */
   List<SolrDocument> selectByq(String q,Long page,Integer rows);

2.接口实现类

	/**
	 * 搜索solr索引库
	 * 
	 * import org.springframework.data.solr.core.query.Criteria;
	 */
	@Override
	public List<SolrDocument> selectByq(String q, Long page, Integer rows) {

		// 设置高亮查询条件(使用我们之前在配置文件中定义的复合域/父作用域)
		HighlightQuery query = new SimpleHighlightQuery();
		Criteria criteria = new Criteria("item_keywords");
		criteria.is(q);
		query.addCriteria(criteria);

		// 设置高亮属性
		HighlightOptions highlightOptions = new HighlightOptions();
		highlightOptions.addField("item_title");// 设置高亮显示的域
		highlightOptions.setSimplePrefix("<em style='color:red'>");// 设置高亮的样式的前缀
		highlightOptions.setSimplePostfix("</em>");// 后缀
		query.setHighlightOptions(highlightOptions);// 将高亮属性设置封装到查询条件中

		// 分页(调用Solr自带的分页方法)
		query.setOffset((page - 1) * rows);
		query.setRows(rows);
		
		/**
		 * HighlightPage: 是一个封装了所有查询的结果集的对象
		 * queryForHighlightPage三个属性 : 指定索引库,指定查询条件 , 将查询的结果封装成指定的对象
		 */
		HighlightPage<SolrDocument> highlightPage = this.solrTemplate.queryForHighlightPage(this.collection, query,
				SolrDocument.class);
		List<HighlightEntry<SolrDocument>> highlighted = highlightPage.getHighlighted();

		for (HighlightEntry<SolrDocument> tbItemHighlightEntry : highlighted) {
			SolrDocument entity = tbItemHighlightEntry.getEntity();// 实体对象，原始的实体对象
			List<HighlightEntry.Highlight> highlights = tbItemHighlightEntry.getHighlights();//标识为高亮的部分
			// 如果有高亮，就做高亮处理
			if (highlights != null && highlights.size() > 0 && highlights.get(0).getSnipplets().size() > 0) {
				entity.setItem_title(highlights.get(0).getSnipplets().get(0));//设置高亮
			}
		}

		List<SolrDocument> list = highlightPage.getContent();
		return list;
	}

3.controller

指定分页的默认属性

	/**
	 * 首页带高亮搜索
	 * 这里的分页是自己指定的,而不是前端控制的 , 所以也就没使用value属性进行校正
	 * 
	 * @param q
	 * @param page 
	 * @param rows
	 * @return
	 */
	@RequestMapping("/list")
	public List<SolrDocument> selectByq(String q,@RequestParam(defaultValue="1") Long page
			 ,@RequestParam(defaultValue="10") Integer rows){
		
		try {
			return this.solrService.selectByq(q, page, rows);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

启动项目, 访问前端页面, 测试关键词索引的效果

购物车功能设计——未登录（Cookie）

购物车的添加——复杂逻辑封装成方法的体现

模仿京东设计,

在没有登录时, 我们是可以添加商品到购物车的(保存到浏览器的Cookie中) ,

但是当我们登录以后, 购物车中的商品会被同步到自己账号下的购物车, 并且无登录下的清空购物车

1.创建项目(继承父项目) ,修改pom文件

<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>ah.szxy.project</groupId>
		<artifactId>bz_parent</artifactId>
		<version>0.0.1-SNAPSHOT</version>
	</parent>
	<artifactId>frontend_cart</artifactId>

	<dependencies>
		<!--Spring Boot Web Starter -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<!--Spring Cloud Eureka Client Starter -->
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
		</dependency>
		<!--Spring Cloud OpenFeign Starter -->
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-openfeign</artifactId>
		</dependency>

		<!-- pojo -->
		<dependency>
			<groupId>ah.szxy.project</groupId>
			<artifactId>common_pojo</artifactId>
			<version>0.0.1-SNAPSHOT</version>
		</dependency>
		<!-- utils -->
		<dependency>
			<groupId>ah.szxy.project</groupId>
			<artifactId>common_utils</artifactId>
			<version>0.0.1-SNAPSHOT</version>
		</dependency>
	</dependencies>


	<!-- 打包插件,打成jar,用于在虚拟机中发布服务 -->
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

2.修改全局配置文件

设置临时购物车缓存到Cookie中的key

spring:       #配置应用名,数据库连接参数
  application:
    name: frontend_cart
    
server:       #配置端口号
  port: 9040
  
eureka:       #配置Eureka服务注册中心地址
  client:
    serviceUrl:
      defaultZone: http://eureka-server:8761/eureka/
      
#设置临时购物车缓存到Cookie中的key
cart_cookie_key: CART_COOKIE_KEY

3.创建启动类

/**
 * 购物车启动类
 * @author chy
 *
 */
@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
public class CartApplication {
	
	public static void main(String[] args) {
		SpringApplication.run(CartApplication.class, args);
	}
}

4.Controller

StringUtils.isBlank:

可以一次性检验字符串(1)是否为null,(2)是否为空字符串(引号中间有空格) 如： " " , (3)是否为 “”, 比isEmpty多了空字符串的校验

@RestController
@RequestMapping("/cart")
public class CartController {
	@Autowired
	private CookieCartService cookieCartService;
	
	/**
	 * 将商品添加到购物车
	 * 需要判断是否登录
	 * @param userId 用户id
	 * @param itemId 商品id
	 * @param num 商品数据
	 * @param request 
	 * @param response
	 * @return
	 */
	@RequestMapping("/addItem")
	public Result addItem(String userId,Long itemId,@RequestParam(defaultValue="1")Integer num
			,HttpServletRequest request, HttpServletResponse response) {
		
		try {
			if (StringUtils.isBlank(userId)) {
				//执行用户未登录状态下的业务逻辑
				return this.cookieCartService.addItem(itemId, num, request, response);
			}else {
				//执行用户登录状态下的业务逻辑
				
				
				
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return Result.error(null);
	}
}

5.Feign接口类

用于调用根据id查询商品的服务, 因为只有查到了商品才能对其进行添加修改等操作

@FeignClient("common-item")
public interface CommonItemFeignClient {
	
	//-------------------------/service/item---------------------------
	@PostMapping("/service/item/selectItemInfo")
	TbItem selectItemInfo(@RequestParam("itemId") Long itemId);
}

7.创建购物车模型

根据购物车列表接口添加相关属性

/**
 * 商品购物车模型
 * 根据购物车列表接口添加相关属性
 * @author chy
 *
 */
public class CartItem implements Serializable{
	
	private Long id;
	private String title;
	private String sellPoint;
	private String image;
	private int num;
	private Long price;
	public Long getId() {
		return id;
	}
	public void setId(Long id) {
		this.id = id;
	}
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	public String getSellPoint() {
		return sellPoint;
	}
	public void setSellPoint(String sellPoint) {
		this.sellPoint = sellPoint;
	}
	public String getImage() {
		return image;
	}
	public void setImage(String image) {
		this.image = image;
	}
	public int getNum() {
		return num;
	}
	public void setNum(int num) {
		this.num = num;
	}
	public Long getPrice() {
		return price;
	}
	public void setPrice(Long price) {
		this.price = price;
	}
	
	
}

7.接口类

因为是未登录,所以用到商品的id,商品的数量,HttpServletRequest ,HttpServletResponse 属性,而没有userId

/**
 * 未登录添加购物车逻辑
 * @author chy
 *
 */
public interface CookieCartService {
	/**
	 * 添加商品到购物车
	 * @param itemId
	 * @param num
	 * @param request 调用Cookie使用
	 * @param response 调用Cookie使用
	 * @return
	 */
	public Result addItem(Long itemId,Integer num,
			HttpServletRequest request, HttpServletResponse response);
}

8.接口实现类

这里注入并调用了在全局配置文件中的设置临时购物车缓存到Cookie中的key

用户未登录状态下的购物车操作业务 (将复杂的逻辑封装成方法,分步实现)

1.获取临时购物车( 从Cookie中获取 )

2.查询商品

3.向购物车中添加商品

4.将购物车通过Cookie写回给浏览器

对1: 如果临时购物车存在,则将其转换成Map输出 ,如果不存在,则创建一个Map集合 , 然后返回这个map

对2: 通过Feign直接调用相关业务

对3: 从购物车的map中查看是否有这个商品 , 如果有,则直接修改数量 : 如果没有,则根据购物车模型新建一个购物车商品对象放入到map中

对4: 将购物车对象转换转换成json格式, 放入Cookie中

import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import ah.szxy.frontend.cart.feign.CommonItemFeignClient;
import ah.szxy.frontend.cart.service.CookieCartService;
import ah.szxy.pojo.TbItem;
import ah.szxy.utils.CartItem;
import ah.szxy.utils.CookieUtils;
import ah.szxy.utils.JsonUtils;
import ah.szxy.utils.Result;

@Service
public class CookieCartServiceImpl implements CookieCartService {

	@Autowired
	private CommonItemFeignClient commonItemFeignClient;
	@Value("${cart_cookie_key}")
	private String cart_cookie_key;
	
	
	/**
	 *用户未登录状态下的购物车操作业务
	 *
	 *将复杂的逻辑封装成方法,分步实现
	 *1.获取临时购物车( 从Cookie中获取 )
	 *2.查询商品
	 *3.向购物车中添加商品
	 *4.将购物车通过Cookie写回给浏览器
	 */
	@Override
	public Result addItem(Long itemId, Integer num, HttpServletRequest request, HttpServletResponse response) {

		// 1.获取临时购物车( 从Cookie中获取 )
		Map<String, CartItem>cart= this.getTempCart(request);
		// 2.查询商品
		TbItem item= this.commonItemFeignClient.selectItemInfo(itemId);
		// 3.向购物车中添加商品
		this.addItemToCart(cart,item,num,itemId);
		// 4.将购物车通过Cookie写回给浏览器
		this.addCookieToClient(request,response,cart);
		
		return Result.ok();
	}

	
	/**
	 * 1.获取临时购物车( 从Cookie中获取 )思路:
	 * 
	 * 如果临时购物车存在,则将其转换成Map输出
	 * 如果不存在,则创建一个Map集合 , 然后返回这个map
	 * 
	 * StringUtils.isBlank:可以一次性检验字符串(1)是否为null,(2)是否为空字符串(引号中间有空格) 如： " " , (3)是否为 "",比isEmpty多了空字符串的校验
	 * @param request
	 * @return
	 */
	private Map<String, CartItem> getTempCart(HttpServletRequest request) {
		//从Cookie中获取Json格式购物车信息
		String cartJsonStr=CookieUtils.getCookieValue(request, this.cart_cookie_key,true);//true使用编码.开启后可以存放中文
		
		if (StringUtils.isBlank(cartJsonStr)) {
			//如果临时购物车不存在,抛出一个空的map集合
			return new HashMap<String, CartItem>();
		}else {
			try {
				//如果临时购物车存在,那么就将其转换成map,便于后续的添加商品操作
				Map<String, CartItem>map =JsonUtils.jsonToMap(cartJsonStr, CartItem.class);  //beanType:指定需要转换的模型 CartItem:商品购物车模型
				return map;
			} catch (Exception e) {
				e.printStackTrace();
			}
			
		}
		
		return new HashMap<String, CartItem>();//购物车不存在的情况,返回这个购物车的对象
	}
    
	/**
	 * 3.向购物车中添加商品
	 * 
	 * 从购物车的map中查看是否有这个商品
	 * 如果有,则直接修改数量
	 * 如果没有,则根据购物车模型新建一个购物车商品对象放入到map中
	 * @param cart
	 * @param item
	 * @param num
	 * @param itemId
	 */
	private void addItemToCart(Map<String, CartItem> cart, TbItem item, Integer num, Long itemId) {
		//从购物车中查询商品
		CartItem cartItem= cart.get(itemId.toString());//map.get(key): 通过cart的key(toString)获取它的value
		if (cartItem==null) {
			//没有相同的商品( 根据购物车模型创建 )
			CartItem c = new CartItem();
			c.setId(item.getId());
			c.setImage(item.getImage());
			c.setNum(num);
			c.setPrice(item.getPrice());
			c.setSellPoint(item.getSellPoint());
			c.setTitle(item.getTitle());
			cart.put(item.getId().toString(),cartItem);//map.put(key,value)
		}else {
			//如果存在相同商品
			cartItem.setNum(cartItem.getNum()+num);
			
		}
	}
	
	/**
	 * 4.将购物车通过Cookie写回给浏览器
	 * 
	 * 将购物车对象转换转换成json格式, 放入Cookie中
	 * @param request
	 * @param response
	 * @param cart 
	 */
	private void addCookieToClient(HttpServletRequest request, 
			HttpServletResponse response, Map<String, CartItem> cart) {
		
		//将购物车对象转换转换成json格式
		String cartJsonStr = JsonUtils.objectToJson(cart);
		//将Json串放入Cookie中
		CookieUtils.setCookie(request, response, this.cart_cookie_key, cartJsonStr, true);
	}
}

浏览器效果

查询购物车列表——遍历map集合,将map中的元素放入的list中

1.controller

/**
	 * 查询购物车列表
	 * @param userId
	 * @param request
	 * @param response
	 * @return
	 */
	@RequestMapping("/showCart")
	public Result showCart(String userId,HttpServletRequest request, HttpServletResponse response) {
		try {
			if (StringUtils.isBlank(userId)) {
				//执行用户未登录状态下的业务逻辑
				return this.cookieCartService.showCart(request, response);
			}else {
				//执行用户登录状态下的业务逻辑
				
				
				
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return Result.error(null);
	}

2.业务层实现类

通过自定义的getTempCart方法获取购物车的map对象,遍历map集合,

将每个元素赋值给一个list集合,然后将这个list集合返回

/**
	 * 查询购物车列表
	 */
	@Override
	public Result showCart(HttpServletRequest request, HttpServletResponse response) {
		//创建返回值对象
		List<CartItem>list=new ArrayList<CartItem>();
		
		//从Cookie中获取购物车对象
		Map<String, CartItem>cartMap=this.getTempCart(request);
		//遍历map集合,将map中的元素放入的list中
		Set<String> keys = cartMap.keySet();
		for (String key : keys) {
			list.add(cartMap.get(key));
		}
		
		return Result.ok(list);
	}

修改购物车中商品的数量——操作Cookie

1.controller

	/**
	 * 修改购物车中商品的数量
	 * @param userId
	 * @param itemId
	 * @param num
	 * @param request
	 * @param response
	 * @return
	 */
	@RequestMapping("/updateItemNum")
	public Result updateItemNum(String userId,Long itemId,@RequestParam(defaultValue="1")Integer num
			,HttpServletRequest request, HttpServletResponse response) {
		
		try {
			if (StringUtils.isBlank(userId)) {
				//执行用户未登录状态下的业务逻辑
				return this.cookieCartService.updateItemNum(itemId, num, request, response);
			}else {
				//执行用户登录状态下的业务逻辑
				
				
				
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return Result.error(null);
	}

2.接口实现类

获取购物车的map对象,通过key获取商品对象,为其数量属性赋值,然后将map返回给Cookie

/**
	 * 更新购物车商品数量
	 */
	@Override
	public Result updateItemNum(Long itemId, Integer num, 
			HttpServletRequest request, HttpServletResponse response) {
		
		//从Cookie中获取购物车对象,通过上面的方法
		Map<String, CartItem>cartMap=this.getTempCart(request);
		//从map中获取商品信息
		CartItem cartItem = cartMap.get(itemId.toString());
		//如果该商品不为空,更改数量信息
		if (cartItem!=null) {
			cartItem.setNum(num);
		}
		
		//将改变添加到Cookie中,通过上面的方法
		this.addCookieToClient(request, response, cartMap);
		return Result.ok();
	}

删除购物车中商品——操作Cookie

1.controller

@RequestMapping("/deleteItemFromCart")
	public Result deleteItemFromCart(String userId,Long itemId,HttpServletRequest request, HttpServletResponse response) {
		
		try {
			if (StringUtils.isBlank(userId)) {
				//执行用户未登录状态下的业务逻辑
				return this.cookieCartService.deleteItemFromCart(itemId, request, response);
			}else {
				//执行用户登录状态下的业务逻辑
				
				
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return Result.error(null);
	}
}

2.业务层实现类

获取购物车的map对象,通过key删除即可,然后将map返回给Cookie

/**
	 * 删除购物车中的商品
	 */
	@Override
	public Result deleteItemFromCart(Long itemId, HttpServletRequest request, HttpServletResponse response) {

		// 从Cookie中获取购物车对象,通过上面的方法
		Map<String, CartItem> cartMap = this.getTempCart(request);
		
		//通过key(itemId)删除商品信息
		cartMap.remove(itemId.toString());
		
		//将改变放到Cookie中
		this.addCookieToClient(request, response, cartMap);
		return Result.ok();
	}

购物车功能设计——登录（Redis）

在登陆状态下 ,会将购物车中的商品数据同步到redis中,

无论你退出多少次 ,登陆后再次点击购物车还是可以看到那些被同步的商品

购物车的添加——复杂逻辑封装成方法的体现

common_redis项目中

@RestController
@RequestMapping("/redis/cart")
public class CartController {
	@Autowired
	private CartService cartService;
	/**
	 * 添加购物车缓存
	 * @param map 需要使用@RequestBody接收前端传来的json数据
	 */
	@RequestMapping("/insertCart")
	public void insertCart(@RequestBody Map<String, Object>map) {
		this.cartService.insertCart(map);
	}
	
	
	/**
	 *从redis缓存中查询购物车信息
	 * @param userId
	 * @return
	 */
	@RequestMapping("/selectCartByUserId")
	public Map<String, CartItem> selectCartByUserId(@RequestParam("userId")String userId){
		return this.cartService.selectCartByUserId(userId);
		
	}
}

2.接口类

public interface SSOService {
	/**
	 * 将用户添加到缓存
	 * @param tbUser
	 * @param token
	 */
	void userLogin(TbUser tbUser,String userToken);
	/**
	 * 用户退出
	 * @param userToken
	 */
	void userLogout(String userToken);
}

3.接口实现类

在这里需要设置绑定用户信息和购物车信息的缓存的key

注意这里使用opsForHash 将数据放入到缓存redis中hash数据类型介绍(第三章第二节)

#配置缓存购物车和用户信息key
frontend_cart_redis_key: frontend:cart:redis:key

@Service
public class CartServiceImpl implements CartService {
	
	@Autowired
	private RedisTemplate<String, Object>redisTemplate;
	@Value("${frontend_cart_redis_key}")
	private String frontend_cart_redis_key;
	
	/**
	 * 添加购物车缓存
	 */
	@Override
	public void insertCart(Map<String, Object> map) {
		//获取用户id信息
		String userId=(String) map.get("userId");
		//获取购物车信息
		Map<String, CartItem> cart=(Map<String, CartItem>) map.get("cart");
		
		//opsForHash用来存放 root key,son key-value形式的数据
		//key:根key:frontend_cart_redis_key, 子key:userId , value: cart
		this.redisTemplate.opsForHash().put(this.frontend_cart_redis_key,userId, cart);
	}
	
	/**
	 * 根据userId查询购物车缓存信息
	 */
	@Override
	public Map<String, CartItem> selectCartByUserId(String userId) {
		//根据Hash类型的两个key查询对应的value
		return (Map<String, CartItem>) this.redisTemplate.opsForHash().get(this.frontend_cart_redis_key, userId);
	}

}

frontend_cart项目

新增三个部分, 对登陆后,购物车逻辑进行完善

1.feign接口

@FeignClient("common-redis")
public interface CommonRedisFeignClient {
	
	//---------------------------/redis/cart-----------------------------------
	@PostMapping("/redis/cart/insertCart")
	void insertCart(@RequestBody Map<String, Object>map);
	
	@PostMapping("/redis/cart/selectCartByUserId")
	Map<String, CartItem> selectCartByUserId(@RequestParam("userId")String userId);
}

2.登陆状态下对购物车的操作

/**
 * 登陆情况下-购物车操作
 * 
 * @author chy
 *
 */
public interface RedisCartService {
	/**
	 * 添加商品到购物车
	 * 
	 * @param itemId
	 * @param num
	 * @param userId
	 * @return
	 */
	Result addItem(Long itemId, Integer num, String userId);

	/**
	 * 查询购物车列表
	 * 
	 * @param userId
	 * @return
	 */
	Result showCart(String userId);
}

3.接口实现类

对复杂的业务逻辑, 我们可以封装成方法,

然后逐个解决 ,但是需要我们仔细斟酌的是返回值以及参数列表

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import ah.szxy.frontend.cart.feign.CommonItemFeignClient;
import ah.szxy.frontend.cart.feign.CommonRedisFeignClient;
import ah.szxy.frontend.cart.service.RedisCartService;
import ah.szxy.pojo.TbItem;
import ah.szxy.utils.CartItem;
import ah.szxy.utils.Result;

@Service
public class RedisCartServiceImpl implements RedisCartService {

	@Autowired
	private CommonItemFeignClient commonItemFeignClient;
	@Autowired
	private CommonRedisFeignClient commonRedisFeignClient;

	/**
	 * 添加商品到购物车 思路: 查询商品->获取购物车->将商品添加到大购物车中->将购物车缓存到Redis中
	 */
	@Override
	public Result addItem(Long itemId, Integer num, String userId) {

		// 1.查询商品
		TbItem tbItem = this.commonItemFeignClient.selectItemInfo(itemId);

		// 2.获取购物车(Redis)
		Map<String, CartItem> cart = this.getCartToRedis(userId);

		// 3.将商品添加到购物车中
		this.addItem(itemId, num, tbItem, cart);

		// 4.将购物车缓存到Redis中
		this.addCartToRedis(userId, cart);

		return Result.ok();
	}

	/**
	 * 2.从redis中获取购物车
	 * 
	 * @param userId
	 * @return
	 */
	private Map<String, CartItem> getCartToRedis(String userId) {

		// 获取购物车
		Map<String, CartItem> cart = this.commonRedisFeignClient.selectCartByUserId(userId);
		// 判断购物车是否为空
		if (cart != null) {// 不为空返回
			return cart;
		} else {
			return new HashMap<String, CartItem>();// 为空新建一个
		}
	}

	/**
	 * 3.将商品添加到购物车中
	 * 
	 * @param itemId
	 * @param tbItem
	 * @param cart
	 * @return
	 */
	private void addItem(Long itemId, Integer num, TbItem tbItem, Map<String, CartItem> cart) {

		// 从购物车map中查询商品
		CartItem cartItem = cart.get(itemId.toString());
		if (cartItem != null) {
			// 不为空,直接改变商品数量
			cartItem.setNum(cartItem.getNum() + num);
		} else {
			// 为空,创建一个新的购物车商品模型
			CartItem c = new CartItem();
			c.setId(tbItem.getId());
			c.setImage(tbItem.getImage());
			c.setNum(num);
			c.setPrice(tbItem.getPrice());
			c.setSellPoint(tbItem.getSellPoint());
			c.setTitle(tbItem.getTitle());
			cart.put(tbItem.getId().toString(), c);// map.put(key,value)

		}
	}

	/**
	 * 4.将购物车缓存到Redis中
	 * 
	 * @param userId
	 * @param cart
	 */
	private void addCartToRedis(String userId, Map<String, CartItem> cart) {

		// 将购物车(map)和用户id(string)在放入一个map中
		Map<String, Object> map = new HashMap<>();
		map.put("userId", userId);
		map.put("cart", cart);
		this.commonRedisFeignClient.insertCart(map);

	}

	/**
	 * 查看购物车(登陆状态下)
	 */
	@Override
	public Result showCart(String userId) {
		// 创建返回值对象
		List<CartItem> list = new ArrayList<CartItem>();

		// 从Redis中获取购物车对象
		Map<String, CartItem> cartMap = this.getCartToRedis(userId);
		
		// 遍历map集合的key,将map中的元素放入的list中
		Set<String> keys = cartMap.keySet();
		for (String key : keys) {
			list.add(cartMap.get(key));
		}

		return Result.ok(list);
	}

}

4.controller

判断用户Id是否为空?补充不为空(if…else…的else)的部分

	/**
	 * 将商品添加到购物车
	 * 需要判断是否登录
	 * @return
	 */
	@RequestMapping("/addItem")
	public Result addItem(String userId,Long itemId,@RequestParam(defaultValue="1")Integer num
			,HttpServletRequest request, HttpServletResponse response) {
		
		try {
			if (StringUtils.isBlank(userId)) {
				//执行用户未登录状态下的业务逻辑
				return this.cookieCartService.addItem(itemId, num, request, response);
			}else {
				
				//执行用户登录状态下的业务逻辑
				return this.redisCartService.addItem(itemId, num, userId);
				
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return Result.error(null);
	}
	
	/**
	 * 查询购物车列表
	 * @return
	 */
	@RequestMapping("/showCart")
	public Result showCart(String userId,HttpServletRequest request, HttpServletResponse response) {
		try {
			if (StringUtils.isBlank(userId)) {
				//执行用户未登录状态下的业务逻辑
				return this.cookieCartService.showCart(request, response);
			}else {
				
				//执行用户登录状态下的业务逻辑
				return this.redisCartService.showCart(userId);
				
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return Result.error(null);
	}

查询购物车列表——遍历map集合,将map中的元素放入的list中

1.controller

完善if…else…中的else语句

@RequestMapping("/deleteItemFromCart")
	public Result deleteItemFromCart(String userId, Long itemId, HttpServletRequest request,
			HttpServletResponse response) {

		try {
			if (StringUtils.isBlank(userId)) {
				// 执行用户未登录状态下的业务逻辑
				return this.cookieCartService.deleteItemFromCart(itemId, request, response);
			} else {
				// 执行用户登录状态下的业务逻辑
				return this.redisCartService.deleteItemFromCart(itemId, userId);

			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return Result.error(null);
	}

2.接口实现类

/**
	 * 查看购物车(登陆状态下)
	 */
	@Override
	public Result showCart(String userId) {
		// 创建返回值对象
		List<CartItem> list = new ArrayList<CartItem>();

		// 从Redis中获取购物车对象
		Map<String, CartItem> cartMap = this.getCartToRedis(userId);

		// 遍历map集合的key,将map中的元素放入的list中
		Set<String> keys = cartMap.keySet();
		for (String key : keys) {
			list.add(cartMap.get(key));
		}

		return Result.ok(list);
	}

修改购物车中商品的数量——操作Redis

1.controller

	@RequestMapping("/updateItemNum")
	public Result updateItemNum(String userId, Long itemId, @RequestParam(defaultValue = "1") Integer num,
			HttpServletRequest request, HttpServletResponse response) {

		try {
			if (StringUtils.isBlank(userId)) {
				// 执行用户未登录状态下的业务逻辑
				return this.cookieCartService.updateItemNum(itemId, num, request, response);
			} else {
				// 执行用户登录状态下的业务逻辑
				return this.redisCartService.updateItemNum(itemId, num, userId);

			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return Result.error(null);
	}

2.接口类

	/**
	 * 修改购物车商品数量
	 */
	@Override
	public Result updateItemNum(Long itemId, Integer num, String userId) {
		// 从Redis中获取购物车对象
		Map<String, CartItem> cartMap = this.getCartToRedis(userId);
		CartItem carItem = cartMap.get(userId.toString());
		if (cartMap != null) {
			carItem.setNum(num);
		}
		// 将新的购物车缓存到redis
		this.addCartToRedis(userId, cartMap);

		return Result.ok();
	}

删除购物车中商品——操作Redis

1.controller

	@RequestMapping("/deleteItemFromCart")
	public Result deleteItemFromCart(String userId, Long itemId, HttpServletRequest request,
			HttpServletResponse response) {

		try {
			if (StringUtils.isBlank(userId)) {
				// 执行用户未登录状态下的业务逻辑
				return this.cookieCartService.deleteItemFromCart(itemId, request, response);
			} else {
				// 执行用户登录状态下的业务逻辑
				return this.redisCartService.deleteItemFromCart(itemId, userId);

			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return Result.error(null);
	}

2.接口类

	/**
	 * 删除购物车中的商品
	 */
	@Override
	public Result deleteItemFromCart(Long itemId, String userId) {
		// 从Redis中获取购物车
		Map<String, CartItem> cartMap = this.getCartToRedis(userId);
		cartMap.remove(itemId.toString());
		this.addCartToRedis(userId, cartMap);
		// 将新的购物车缓存到redis
		return Result.ok();
	}

七、用户注册与登录服务——单点登录(SSO)功能实现

介绍

单点登录(SingleSignOn，SSO)，就是通过用户的一次性鉴别登录。当用户在身份认证服务器上登录一次以后，即可获得访问单点登录系统中其他联邦系统和应用软件的权限，同时这种实现是不需要管理员对用户的登录状态或其他信息进行修改的，

这意味着在多个应用系统中，用户只需一次登录就可以访问所有相互信任的应用系统。

这种方式减少了由登录产生的时间消耗，辅助了用户管理，是目前比较流行的。

环境搭建

1.创建项目.修改pom文件

Eureka,Feign,LCN,Mapper(pojo),utils,打包插件

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>ah.szxy.project</groupId>
    <artifactId>bz_parent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <artifactId>frontend_sso</artifactId>
	
	<dependencies>
		<!--Spring Boot Web Starter-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<!--Spring Cloud Eureka Client Starter-->
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
		</dependency>
		<!--Spring Cloud OpenFeign Starter -->
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-openfeign</artifactId>
		</dependency>
		<!-- lcn client -->
		<dependency>
			<groupId>ah.szxy.project</groupId>
			<artifactId>common_tx_manager_client</artifactId>
			<version>0.0.1-SNAPSHOT</version>
		</dependency>
		
		<!-- Mapper -->
		<dependency>
			<groupId>ah.szxy.project</groupId>
			<artifactId>common_mapper</artifactId>
			<version>0.0.1-SNAPSHOT</version>
		</dependency>
		<!-- Utils -->
		<dependency>
			<groupId>ah.szxy.project</groupId>
			<artifactId>common_utils</artifactId>
			<version>0.0.1-SNAPSHOT</version>
		</dependency>
	</dependencies>
	
	<!-- 打包插件,打成jar,用于在虚拟机中发布服务 -->
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

2.创建全局配置文件

spring:       #配置应用名,数据库连接参数
  application:
    name: frontend-sso
  datasource:
    driverClassName: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/bz_shop?useSSL=false
    username: root
    password: root
    type: com.alibaba.druid.pool.DruidDataSource
  redis:
    host: 192.168.179.131
    port: 6379
    
server:       #配置端口号
  port: 9090

eureka:       #配置Eureka服务注册中心地址
  client:
    serviceUrl:
      defaultZone: http://eureka-server:8761/eureka/

tx-lcn: 
  client:
      manager-address: 192.168.179.138:8070    #TM服务端事务消息端口

3.启动类

开启Eureka发现,Feign客户端,Mapper扫描

@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
@MapperScan("ah.szxy.mapper")
public class FrontendSsoApplication {
	public static void main(String[] args) {
		SpringApplication.run(FrontendSsoApplication.class, args);
	}
}

注册功能实现

注册校验接口文档

注册接口文档

上游服务

不需要操作Redis,故只有上游服务

1.controller(根据接口文档书写)

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import ah.szxy.frontend.sso.service.SSOService;
import ah.szxy.pojo.TbUser;
import ah.szxy.utils.Result;

@RestController
@RequestMapping("/sso")
public class SSOController {
	
	@Autowired
	private SSOService ssoService;
	/**
	 * 用户注册校验
	 * @param checkValue
	 * @param checkFlag
	 * @return
	 */
	@RequestMapping("/checkUserInfo/{checkValue}/{checkFlag}")
	public Result checkUserInfo(@PathVariable String checkValue,@PathVariable Integer checkFlag) {
		
		try {
			return this.ssoService.checkUserInfo(checkValue, checkFlag);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return Result.error(null);
	}
	
	/**
	 * 用户登陆失败
	 * @param tbUser
	 * @return
	 */
	@RequestMapping("/userRegister")
	public Result userRegister(TbUser tbUser) {
		
		try {
			return this.ssoService.userRegister(tbUser);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return Result.error(null);
	}
}

2.接口类

public interface SSOService {
	/**
	 * 用户注册校验
	 * @param checkValue
	 * @param checkFlag
	 * @return
	 */
	Result checkUserInfo(String checkValue,Integer checkFlag);
	/**
	 * 用户注册
	 * @param tbUser
	 * @return
	 */
	Result userRegister(TbUser tbUser);
}

3.接口实现类

注意: 在注册时(相当于添加数据),需要使用MD5进行不可逆的加密,并且补齐表单没有的数据

在数据库保存的是加密后的数据, 进行验证时,对密码直接再使用一次MD5加密,然后将加密后结果与数据库中的数据比对,如果一样说明密码正确

import java.util.Date;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import ah.szxy.frontend.sso.service.SSOService;
import ah.szxy.mapper.TbUserMapper;
import ah.szxy.pojo.TbUser;
import ah.szxy.pojo.TbUserExample;
import ah.szxy.pojo.TbUserExample.Criteria;
import ah.szxy.utils.MD5Utils;
import ah.szxy.utils.Result;

@Service
public class SSOServiceImpl implements SSOService {
	
	@Autowired
	private TbUserMapper tbUserMapper;
	
	/**
	 * 用户注册校验
	 */
	@Override
	public Result checkUserInfo(String checkValue, Integer checkFlag) {
		TbUserExample example=new TbUserExample();
		Criteria c = example.createCriteria();
		
		//根据checkFlag判断时校验用户名还是手机号, 1:用户名,2手机号
		if (checkFlag==1) {
			c.andUsernameEqualTo(checkValue);
		}else if (checkFlag==2) {
			c.andPhoneEqualTo(checkValue);
		}
		
		//查询符合条件的个数,如果不为0说明重复
		int result = this.tbUserMapper.countByExample(example);
		if (result!=0) {
			return Result.error(null);
		}else {
			return Result.ok(checkValue);
		}
	}
	
	/**
	 * 用户注册(插入操作)
	 */
	@Override
	public Result userRegister(TbUser tbUser) {
		
		//将密码使用MD5进行加密
		String pwd=MD5Utils.digest(tbUser.getPassword());
		tbUser.setPassword(pwd);
		//插入必做-----补齐数据
		Date date=new Date();
		tbUser.setCreated(date);
		tbUser.setUpdated(date);
		
		this.tbUserMapper.insert(tbUser);
		return Result.ok();
	}

}

4.MD5加密的工具类

package ah.szxy.utils;

import java.security.MessageDigest;

/**
 * MD5加密工具
 */
public class MD5Utils {
	
	public static String digest(String source){
		try{
			MessageDigest digest = MessageDigest.getInstance("MD5");
			
			byte[] temp = digest.digest(source.getBytes());
			
			StringBuilder builder = new StringBuilder("");
			
			for(byte b : temp){
				String s = Integer.toHexString(0xFF & b);
				if(s.length() == 1){
					s = "0" + s;
				}
				builder.append(s);
			}
			
			return builder.toString();
		}catch(Exception e){
			return null;
		}
	}

}

用户登陆功能的实现

思路:

1.根据用户名密码查询数据库

2.判断用户是否存在. 如果用户存在,将userToken添加到 Redis中(他是利用UUID生成的一个字符串,用于唯一标识用户的信息)

3.调用添加userToken到redis的服务,判断是否添加成功

下游服务(操作Redis)

用户登陆实质 : 将用户的userToken信息存到Redis中

用户退出实质: 将用户的userToken信息从Redis中移除

1.接口类

	/**
	 * 将用户添加到缓存
	 * @param tbUser
	 * @param token
	 */
	void userLogin(TbUser tbUser,String userToken);
	/**
	 * 用户退出
	 * @param userToken
	 */
	void userLogout(String userToken);

2.实现类

#全局配置文件中
#用户信息的缓存
user_session_redis_key: user:session:redis:key

@Service
public class SSOServiceImpl implements SSOService {
	
	@Autowired
	private RedisTemplate<String, Object>redisTemplate;
	@Value("${user_session_redis_key}")
	private String user_session_redis_key;
	
	/**
	 * 用户登陆
	 */
	@Override
	public void userLogin(TbUser tbUser, String userToken) {
		//出于安全考虑,将密码设置空
		tbUser.setPassword("");
		
		//添加缓存,设置key(固定字符+token),设置value,设置超时时间,设置超时时间单位
		this.redisTemplate.opsForValue().set(this.user_session_redis_key+":"+userToken, tbUser, 1, TimeUnit.DAYS);
	}

	/**
	 * 用户退出
	 */
	@Override
	public void userLogout(String userToken) {
		this.redisTemplate.delete(this.user_session_redis_key+":"+userToken);
	}

}

3.controller

参数列表中存在单个参数时,建议使用@RequestParam进行参数矫正,为对象时使用@RequestBody,主要用来接收前端传递给后端的json字符串中的数据的

@RestController
@RequestMapping("/redis/sso")     
public class SSOController {
	@Autowired
	private SSOService ssoService;
	/**
	 * 将用户信息添加进缓存
	 * @param tbUser
	 * @param token
	 */
	@RequestMapping("/userLogin")
	public void userLogin(@RequestBody TbUser tbUser,@RequestParam(value="userToken") String userToken) {
		this.ssoService.userLogin(tbUser, userToken);
	}
	
	@RequestMapping("/logout")
	public void userLogout(@RequestParam(value="userToken") String userToken) {
		this.ssoService.userLogout(userToken);
	}
}

上游服务

1.controller

注意对接前端接口, 在用户退出的时候,前端发送的是token,所以需要参数矫正

否则出现: status 400 reading CommonRedisFeignClient#userLogout(String)

	/**
	 * 用户登陆
	 * @param username
	 * @param password
	 * @return
	 */
	@RequestMapping("/userLogin")
	public Result userLogin(String username,String password) {
		
		try {
			return this.ssoService.userLogin(username, password);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return Result.error(null);
	}
	/**
	 * 登陆退出
	 * @param userToken
	 * 
	 * 注意:前端表单发送的是token,而不是userToken,所以需要进行参数矫正
	 *  否则出现: status 400 reading CommonRedisFeignClient#userLogout(String)
	 * @return
	 */
	@RequestMapping("/logOut")
	public Result logOut(@RequestParam(value="token")String userToken) {
		
		try {
			return this.ssoService.logOut(userToken);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return Result.error(null);
	}

2.Feign接口

@FeignClient("common-redis")
public interface CommonRedisFeignClient {
	
	//----------------------------/redis/sso-------------------------------------------------
	@PostMapping("/redis/sso/userLogin")
	void userLogin(@RequestBody TbUser tbUser,@RequestParam(value="userToken") String userToken);
	
	@PostMapping("/redis/sso/logout")
	void userLogout(@RequestParam(value="userToken") String userToken);
}

3.接口类

Result userRegister(TbUser tbUser);
	/**
	 * 用户登陆
	 * @param tbUser
	 * @return
	 */
	Result userLogin(String username,String password);
	/**
	 * 登陆退出
	 * @param userToken
	 * @return
	 */
	Result logOut(String userToken);

4.实现类

1.根据用户名密码查询数据库

2.判断用户是否存在. 如果用户存在,将userToken添加到 Redis中(他是利用UUID生成的一个字符串,用于唯一标识用户的信息)

3.调用添加userToken到redis的服务,判断是否添加成功

	/**
	 * 用户登陆,并向Redis中添加userToken的缓存信息
	 */
	@Override
	public Result userLogin(String username, String password) {

		// 1.根据用户名密码查询数据库
		TbUser tbUser = this.login(username, password);

		// 2.判断用户是否存在. 如果用户存在,将userToken添 加 到 Redis中
		if (tbUser != null) {
			// 生成userToken
			String userToken = UUID.randomUUID().toString();
			// 3.调用添加userToken到redis的服务,判断是否添加成功
			Integer flag = this.insertUserToRedis(tbUser, userToken);
			if (flag == 200) {
				// 如果添加缓存成功,返回这些信息
				Map<String, String> map = new HashMap<String, String>();
				map.put("token", userToken);
				map.put("userId", tbUser.getId().toString());
				map.put("username", tbUser.getUsername());
				return Result.ok(map);

			} else if (flag == 500) {
				// 如果添加缓存失败,提示登陆失败
				return Result.error("登陆失败");
			}

		}
		return Result.error("用户名或密码有误,请重新输入");
	}

	/**
	 * 封装添用户信息加缓存到redis的方法
	 * 
	 * @param tbUser
	 * @param userToken 作为用户的key
	 * @return
	 */
	private Integer insertUserToRedis(TbUser tbUser, String userToken) {
		try {
			// 对于在redis插入缓存需要捕获异常,以免影响下面代码的执行
			this.commonRedisFeignClient.userLogin(tbUser, userToken);
			return 200;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return 500;
	}

	/**
	 * 封装用户登陆的方法
	 * @param username
	 * @param password
	 */
	private TbUser login(String username, String password) {
		//因为在注册时被加密,所以在登陆时,也需要通过加密后的字符串查询
		String pwd = MD5Utils.digest(password);

		
		//查询是否存在
		TbUserExample example=new TbUserExample();
		Criteria c = example.createCriteria();
		c.andUsernameEqualTo(username);
		c.andPasswordEqualTo(pwd);
		List<TbUser> list = this.tbUserMapper.selectByExample(example);
		if (!list.isEmpty()) {//对查询到的结果需要判空
			return list.get(0);
		}
		return null;
	}
	
	/**
	 * 登陆退出
	 */
	@Override
	public Result logOut(String userToken) {
		
		this.commonRedisFeignClient.userLogout(userToken);
		return Result.ok();
	}

测试

用户登陆成功后,redis会显示缓存信息

用户退出后 ,这些缓存信息会被删除

拦截器的使用-去结账时检测用户是否登录(Cookie和Redis)

拦截器是我们项目开发的重要一环, 保准数据的安全性和准确性和完整性

在校验时,不仅需要去Cookie检查用户的token是否存在,而且需要去Redis检查token是否存在

那为什么要同时检验Cookie和Redis中的token呢?

因为他们都是有有效期的, 有可能因为一方的有效期过期而导致服务器端(Redis)或客户端(Cookie)中的token已被移除,但是仍能够进行现金操作,会带来相关的安全问题.

这时候就需要有拦截器的出现 ,任何一方没有token,拦截它并让他重新登陆

下游服务Common-Redis(检测token是否存在)

1.SSOController中

	/**
	 * 结算时,检测用户是否登录
	 * 根据用户token 校验用户在redis 中是否失效
	 */
	@RequestMapping("/checkUserToken")
	public TbUser checkUserToken(@RequestParam String token) {
		return this.ssoService.checkUserToken(token);
	}

2.在SSOService添加抽象方法

/**
	 * 结算时,检查用户是否登录
	 * @param token
	 * @return
	 */
	TbUser checkUserToken(String token);

3.在实现类重写抽象方法

/**
	 * 结算时,检测用户是否登录
	 * 首先去检查是否有token
	 * 然后检查是否有缓存
	 */
	@Override
	public TbUser checkUserToken(String token) {
		
		return (TbUser) this.redisTemplate.opsForValue().get(this.user_session_redis_key+":"+token);
	}

上游服务frontend_cart

1.CommonRedisFeignClient声明需要调用的下游服务方法的接口

	@PostMapping("/redis/sso/checkUserToken")
	TbUser checkUserToken(@RequestParam String token);

2.接口类

/**
 * 校验用户登录业务层接口
 * @author chy
 *
 */
public interface UserCheckService {
	/**
	 * 校验用户登录(通过查询Redis中)
	 * @param token
	 * @return
	 */
	TbUser checkUserToken(String token);
}

3.实现类

@Service
public class UserCheckServiceImpl implements UserCheckService {
	
	@Autowired
	private CommonRedisFeignClient commonRedisFeignClient;
	
	/**
	 * 校验用户登录(通过查询Redis中)
	 */
	@Override
	public TbUser checkUserToken(String token) {
		return this.commonRedisFeignClient.checkUserToken(token);
	}

}

4.UserLoginInterceptor拦截器类

a.对用户的token 做判断(通过Cookie),通过HttpServletRequest 对象获取

b.如果用户token 不为空，则校验用户在redis 中是否失效(调用下游服务,通过一个固定长字符串加上token作为key来查询value,也就是用户信息tbUser)

为何查询redis调用的参数也是从Cookie中查询的token呢?

可以这样想,如果从服务端token如果都查不到token,那么肯定直接拦截到登陆页面了,

根本不需要进行下一步,只有第一步能够查到的情况下才会进行第二次查询Redis中的token

package ah.szxy.frontend.cart.intercepter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import ah.szxy.frontend.cart.service.UserCheckService;
import ah.szxy.pojo.TbUser;

/**
 * 在结算之前判断用户是否登录的拦截器
 * @author chy
 *
 */
@Component
public class UserLoginInterceptor implements HandlerInterceptor{
	
	@Autowired
	private UserCheckService userCheckService;
	
	@Override
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
		
		//1.对用户的token 做判断(通过Cookie)
		String token = request.getParameter("token");
		if(StringUtils.isBlank(token)){
		return false;
		}
		
		//2.如果用户token 不为空，则校验用户在redis 中是否失效
		TbUser tbUser = this.userCheckService.checkUserToken(token);
		if(tbUser == null){
		return false;
		}
		return true;//放行
	}
	
		
	@Override
	public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
			ModelAndView modelAndView) throws Exception {
		// TODO Auto-generated method stub
		HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
	}

	@Override
	public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
			throws Exception {
		// TODO Auto-generated method stub
		HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
	}
		
}

5.拦截器的配置类

package ah.szxy.frontend.cart.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import ah.szxy.frontend.cart.intercepter.UserLoginInterceptor;

/**
 * 配置拦截器类
 * 
 * 相当于在SpringMVC中配置xml文件
 * 配置拦截器拦截的路径
 * @author chy
 *
 */
@Configuration
public class WebApplication implements WebMvcConfigurer{
	
	//注入拦截器
	@Autowired
	private UserLoginInterceptor userLoginInterceptor;
	
	
	//这里无需添加@Bean注解,因为它实现了WebMvcConfigurer接口,会读取被复写的方法
	@Override
	public void addInterceptors(InterceptorRegistry registry) {
		InterceptorRegistration registration =registry.addInterceptor(this.userLoginInterceptor);
		
		//拦截那个URI路径
		registration.addPathPatterns("/cart/goSettlement/**");
	}
	
}

八、开发百战商城前台系统

服务网关设置与超时调优

服务网关整合Hystrix环境搭建

1.创建项目,修改pom文件

<dependencies>
		<!-- web启动器 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<!-- Eureka客户端 -->
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
		</dependency>
		<!-- 网关服务 -->
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-zuul</artifactId>
		</dependency>
	</dependencies>
	<!-- 打包插件 -->
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

2.修改全局配置文件 application.yml

7070是网关服务的端口号(可自定义),

通过访问http://localhost:7070/即可访问到网关服务,根据定义的路由规则访问到对应服务

配置网关请求服务的超时时间, 解决使用网关后, 其他配置无误后页面超时导致的访问失败的问题

spring:       #配置应用名,数据库连接参数
  application:
    name: common-zuul
    
server:       #配置端口号
  port: 7070
  
eureka:       #配置Eureka服务注册中心地址
  instance:     #使用真实ip，而不使用域名
    prefer-ip-address: true
  client:
    serviceUrl:
      defaultZone: http://eureka-server:8761/eureka/
      
zuul:
  sensitive-headers: true #全局配置，解决在网关服务中不传递请求头的问题(Cookie)
  routes:
    #后台商品服务路由规则   
    backend_item:    #服务名之间的连接号最好使用连接号"-"而不是下划线"_",该种配置是简化配置,这一行必须是服务名
      path: /backend_item/**
    #后台CMS 服务的路由规则
    backend_content:
      path: /backend_content/**
      
    #前台首页服务的路由规则
    frontend_portal:
      path: /frontend_potal/**
    #前台搜索服务的路由规则
    frontend-search:
      path: /frontend_search/**
    #前台用户注册与登录服务
    frontend-sso:
      path: /frontend_sso/**
    #前台订单服务
    frontend-order:
      path: /frontend_order/**
    #前台购物车服务
    frontend-cart:
      path: /frontend_cart/**
      
#配置网关请求服务的超时时间
#第一层hystrix 的超时时间
hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 5000 #默认为线程池隔离，默认超时时间为1000ms
            
#第二层Ribbon 的超时时间设置
ribbon:
  ConnectTimeout: 3000 #设置请求连接的超时时间默认为5 秒
  ReadTimeout: 3000 #设置请求处理超时时间默认为5 秒

3.启动类

/**
 * 网关服务
 * @author chy
 *
 */
@SpringBootApplication
@EnableDiscoveryClient
@EnableZuulProxy
public class CommonZuulApplicatio {
	public static void main(String[] args) {
		
		SpringApplication.run(CommonZuulApplicatio.class, args);
	}
}

4.需要我们将以前服务的端口指向网关服务的端口

6.需要我们匹配路由规则的path

7.测试各项功能能否正常运行

注意: 配置网关后 ,需要首先启动网关服务再启动下游服务然后是上游服务

在网关中实现对服务降级处理

返回托底数据, 并在控制台打印, 需要为每个项目都配置一个这样的托底类undefined

package ah.szxy.common.zuul.fallback;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;

import org.springframework.cloud.netflix.zuul.filters.route.FallbackProvider;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.stereotype.Component;

/**
 * 对getRoute中的方法返回值中的项目进行降级处理,返回托底数据
 * 
 * 1.创建托底类,实现FallbackProvider接口 
 * 2.返回一个ClientHttpResponse对象
 * 效果:会在服务超时后,返回托底数据信息
 * @author chy
 *
 */
@Component
public class BackendContentFallback implements FallbackProvider {

	@Override
	public String getRoute() {
		return "backend_content";
	}

	@Override
	public ClientHttpResponse fallbackResponse(String route, Throwable cause) {
		if (cause != null && cause.getCause() != null) {
			String c = cause.getCause().getMessage();
			System.out.println(route + "\t" + c);
		}
		return new ClientHttpResponse() {

			@Override
			public HttpHeaders getHeaders() {
				HttpHeaders headers = new HttpHeaders();
				MediaType mediaType = new MediaType("application", "json", Charset.forName("utf-8"));
				headers.setContentType(mediaType);
				return headers;
			}

			@Override
			public InputStream getBody() throws IOException {
				String content = "服务超时，请重试";
				return new ByteArrayInputStream(content.getBytes());
			}

			@Override
			public String getStatusText() throws IOException {
				return this.getStatusCode().getReasonPhrase();
			}

			@Override
			public HttpStatus getStatusCode() throws IOException {
				return HttpStatus.OK;
			}

			@Override
			public int getRawStatusCode() throws IOException {
				return this.getStatusCode().value();
			}

			@Override
			public void close() {

			}
		};

	}

}

使用令牌桶算法实现限流

Google令牌桶实现限流原理

使用Postman 测试服务降级与网关限流

限流

查看托底数据

九、在项目中配置分布式配置中心

分布式配置中心介绍传送门

在项目中配置分布式配置中心的服务端

配置分布式配置中心的服务端,并且实现手动刷新

0.安装RabbitMQ(因为使用了RabbitMQ作为消息总线)

1.创建项目,修改pom文件

	<dependencies>
		<!--Spring Boot Web Starter -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<!--Spring Cloud Eureka Client Starter -->
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
		</dependency>
		<!--Spring Cloud Config Server -->
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-config-server</artifactId>
		</dependency>
		<!--Spring Cloud AMQP: （RabbitMQ） Starter -->
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-bus-amqp</artifactId>
		</dependency>
	</dependencies>

	<!-- 打包插件,打成jar,用于在虚拟机中发布服务 -->
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

2.修改全局配置文件application.yml

spring:       #配置应用名,数据库连接参数
  application:
    name: common-config
  cloud:      #配置配置中心服务端地址
    config:
      server:
        git:
          uri: https://gitee.com/TimePause/bzshop_config
    bus:
      refresh:
        enabled: true #开启自动刷新
  rabbitmq:     #配置RabbitMQ连接参数(在分布式配置中心服务端中添加消息总线)
    host: 192.168.179.136
    port: 5672
    username: mquser
    password: mquser  
    virtual-host: /  
    listener:
      simple:
        retry:
          enabled: true #开启重试
          max-attempts: 5  #重试次数

    
    
    
server:       #配置端口号
  port: 9000
  
eureka:       #配置Eureka服务注册中心地址
  instance:     #使用真实ip，而不使用域名
    prefer-ip-address: true
  client:
    serviceUrl:
      defaultZone: http://eureka-server:8761/eureka/
      
management:
  endpoints:
    web:
      exposure:
        include: bus-refresh  #在Greewitch.SR2 版中需要开启

3.创建启动类

@EnableConfigServer开启配置中心的注解

package ah.szxy.common.config;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.config.server.EnableConfigServer;

@SpringBootApplication
@EnableDiscoveryClient
@EnableConfigServer
public class CommonConfigApplication {
	
	public static void main(String[] args) {
		SpringApplication.run(CommonConfigApplication.class, args);
	}
}

4.登录gitee, 在gitee 中创建远程仓库

在项目中配置分布式配置中心的客户端

1.添加如下坐标

<!--Spring Cloud Config Client Starter -->
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-config</artifactId>
		</dependency>
		<!--Spring Cloud AMQP: （RabbitMQ） Starter -->
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-bus-amqp</artifactId>
		</dependency>

2.在每个客户端服务的配置文件application.yml中添加如下配置

spring:
  rabbitmq:     #配置RabbitMQ连接参数(在分布式配置中心客户端中添加消息总线)
    host: 192.168.179.136
    port: 5672
    username: mquser
    password: mquser  
    virtual-host: /  
    listener:
      simple:
        retry:
          enabled: true #开启重试
          max-attempts: 5  #重试次数

3.将配置文件application.yml修改名称后(-dev)上传到gitee 远程仓库中,目标分支master

上传所有项目, 除了配置中心服务端以及Eureka服务端,并删除本地项目的配置文件

4.在每个客户端服务中创建bootstrap.yml 文件

spring:
  cloud:
    config:
      discovery:
        enabled: true
        service-id: common-config #指定配置中心服务端的服务名称
      name: frontend-cart #对应的{application}部分
      profile: dev #对应的{profile}部分
      uri: http://127.0.0.1:9000 #配置中心的具体地址，Greenwich 版中需要添加
      label: master

eureka:       #配置Eureka服务注册中心地址
  instance:     #使用真实ip，而不使用域名
    prefer-ip-address: true
  client:
    serviceUrl:
      defaultZone: http://eureka-server:8761/eureka/

5.测试分布式配置中心

注意: 配置分布式配置中心 ,需要首先启动配置中心服务再启动网关服务然后是下游服务和上游服务

6.测试自动刷新配置信息curl -X POST http://localhost:9000/actuator/bus-refresh

十、通过Hystrix 对下游服务做降级处理

返回托底数据实现步骤

1.创建托底类,继承FallbackFactory接口,参数类型为Feign接口类CommonItemFeignClient
2.实现相关方法,并在返回值中实例化Feign接口类,然后自动实例化它的接口
3.修改feign的接口类,在@FeignClient注解中添加fallbackFactory,指定这个类并且以.class结尾
4.在下游服务中在返回结果前,对需要事务操作(增删改)的数据进行判断,如果为空,手动抛出

托底类

package ah.szxy.backend.item.fallback;

import java.util.List;
import java.util.Map;

import org.springframework.stereotype.Component;

import ah.szxy.backend.item.feign.CommonItemFeignClient;
import ah.szxy.pojo.TbItem;
import ah.szxy.pojo.TbItemCat;
import ah.szxy.pojo.TbItemDesc;
import ah.szxy.pojo.TbItemParam;
import ah.szxy.pojo.TbItemParamItem;
import ah.szxy.utils.PageResult;
import feign.hystrix.FallbackFactory;

/**
 * Common-item 服务返回托底数据
 * 
 * 返回托底数据实现步骤
 * 1.创建托底类,继承FallbackFactory接口,参数类型为Feign接口类CommonItemFeignClient
 * 2.实现相关方法,并在返回值中实例化Feign接口类,然后自动实例化它的接口
 * 3.修改feign的接口类,在@FeignClient注解中添加fallbackFactory,指定这个类并且以.class结尾
 * 4.在下游服务中在返回结果前,对需要事务操作(增删改)的数据进行判断,如果为空,手动抛出RuntimeException()查不需要
 * @author chy
 *
 */
@Component
public class CommonItemFeignClientFallbackFactory implements
		FallbackFactory<CommonItemFeignClient>{

	@Override
	public CommonItemFeignClient create(Throwable arg0) {

		return new CommonItemFeignClient() {
			
			@Override
			public Integer updateTbItemParamItem(TbItemParamItem tbItemParamItem) {
				// TODO Auto-generated method stub
				return null;
			}
			
			@Override
			public Integer updateItemDesc(TbItemDesc tbItemDesc) {
				// TODO Auto-generated method stub
				return null;
			}
			
			@Override
			public Integer updateItem(TbItem tbItem) {
				// TODO Auto-generated method stub
				return null;
			}
			
			@Override
			public PageResult selectTbItemAllByPage(Integer page, Integer rows) {
				// TODO Auto-generated method stub
				return null;
			}
			
			@Override
			public TbItemParam selectItemParamByItemCatId(Long itemCatId) {
				// TODO Auto-generated method stub
				return null;
			}
			
			@Override
			public PageResult selectItemParamAll(Integer page, Integer rows) {
				// TODO Auto-generated method stub
				return null;
			}
			
			@Override
			public List<TbItemCat> selectItemCategoryByParentId(Long id) {
				// TODO Auto-generated method stub
				return null;
			}
			
			@Override
			public Map<String, Object> preUpdate(Long itemId) {
				// TODO Auto-generated method stub
				return null;
			}
			
			@Override
			public Integer insertTbItemParamItem(TbItemParamItem tbItemParamItem) {
				// TODO Auto-generated method stub
				return null;
			}
			
			@Override
			public Integer insertTbItem(TbItem tbItem) {
				// TODO Auto-generated method stub
				return null;
			}
			
			@Override
			public Integer insertItemParam(TbItemParam tbItemParam) {
				// TODO Auto-generated method stub
				return null;
			}
			
			@Override
			public Integer insertItemDesc(TbItemDesc tbItemDesc) {
				// TODO Auto-generated method stub
				return null;
			}
			
			@Override
			public Integer deleteItemParamById(Long id) {
				// TODO Auto-generated method stub
				return null;
			}
			
			@Override
			public Integer deleteItemById(TbItem tbItem) {
				// TODO Auto-generated method stub
				return null;
			}
		};
	}

}

修改Feign

手动抛出异常,因为托底数据的存在会导致项目不会输错误信息,

但是分布式事务LCN需要检测异常的存在才能进行数据的回滚,所以在增删改时需要手动抛出异常

十一、分布式日志管理

分布式日志管理相关软件安装以及整合详细介绍

1访问Kibanahttp://192.168.70.140:5601/app/kibana

2.修改pom文件

<!--Logback-->
<dependency>
<groupId>net.logstash.logback</groupId>
<artifactId>logstash-logback-encoder</artifactId>
</dependency>

3.添加日志配置文件logback.xml

<?xml version="1.0" encoding="UTF-8" ?>
<configuration>
    <!--定义日志文件的存储地址 勿在 LogBack 的配置中使用相对路径-->
    <property name="LOG_HOME" value="${catalina.base}/logs/" />
    <!-- 控制台输出 -->
    <appender name="Stdout" class="ch.qos.logback.core.ConsoleAppender">
        <!-- 日志输出编码 -->
        <layout class="ch.qos.logback.classic.PatternLayout">
            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n
            </pattern>
        </layout>
    </appender>

    <!-- 为 logstash 输出的 JSON 格式的 Appender -->
    <appender name="logstash"  class="net.logstash.logback.appender.LogstashTcpSocketAppender">
        <destination>192.168.179.138:9250</destination> <!-- 日志输出编码 -->
        <encoder class="net.logstash.logback.encoder.LoggingEventCompositeJsonEncoder">
            <providers>
                <timestamp>
                    <timeZone>UTC</timeZone>
                </timestamp>
                <pattern>
                    <pattern>
                        {"severity": "%level",
                        "service": "${springAppName:-}",
                        "trace": "%X{X-B3-TraceId:-}",
                        "span": "%X{X-B3-SpanId:-}",
                        "exportable": "%X{X-Span-Export:-}",
                        "pid": "${PID:-}",
                        "thread": "%thread",
                        "class": "%logger{40}",
                        "rest": "%message"
                        }
                    </pattern>
                </pattern>
            </providers>
        </encoder>
    </appender>

    <!-- 日志输出级别 -->
    <root level="INFO">
        <appender-ref ref="Stdout" />
        <appender-ref ref="logstash" />
    </root>

</configuration>

4.通过Kibana 查询日志

十二、项目部署

1.给每个项目项目POM 文件中添加打包插件,并打包父项目

2.打包后,按照下面步骤执行打包教程

资料分享

链接：https://pan.baidu.com/s/1INJR7v4Ue77Xx6ATkLmBGw

提取码：zna4

本文参与腾讯云自媒体分享计划，分享自作者个人站点/博客。

原始发表：2019-10-04 ，如有侵权请联系 cloudcommunity@tencent.com 删除

网络安全

lucene/solr

分布式

云数据库 Redis

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体分享计划，欢迎热爱写作的你一起参与！