本文我在前面的基础上来实现各个业务模块。结构图如下

一、模拟登陆功能

1.e-book-user-service 处理

1.1 pojo序列化

1.2 service接口处理

@RequestMapping("/user")
public interface UserService {

	// 用户登录
	@RequestMapping(value = "/login", method = RequestMethod.GET)
	public User login(@RequestParam("userName") String userName
			, @RequestParam("password") String password);
}

2.e-book-user-provider处理

2.1 创建service实现

@Service
public class UserServiceImpl {

	@Autowired
	private UserMapper userMapper;

	public User login(String userName,String password){
		UserExample example = new UserExample();
		example.createCriteria()
				.andUserNameEqualTo(userName)
				.andPasswordEqualTo(password);
		List<User> list = userMapper.selectByExample(example);
		if(list == null || list.size() != 1){
			return null;
		}else{
			return list.get(0);
		}
	}
}

2.2 创建controller

@RestController
public class UserController implements UserService{

	@Autowired
	private UserServiceImpl service;

	@Override
	public User login(String userName, String password) {
		User user = service.login(userName, password);
		return user;
	}

}

2.3 修改启动类

  注意相关的注解的添加

/**
 * User的启动类
 * @author dengp
 *
 */
@EnableEurekaClient
@SpringBootApplication
@MapperScan("com.bobo.mapper")
public class Start {

    public static void main(String[] args) {
        SpringApplication.run(Start.class, args);
    }
}

2.4 启动服务

  启动服务，在Eureka注册中心中可以发现对应的服务

3.e-book-consumer处理

  在controller中简单模拟登陆操作，然后启动consumer服务，测试是否能够访问

@RestController
public class ConsumerController {

	@Autowired
	private ConsumerOrderService orderService;

	@Autowired
	private ConsumerProductService productService;

	@Autowired
	private ConsumerTradeService tradeService;

	@Autowired
	private ConsumerUserService userService;

	/**
	* 模拟内容： 登录 查看产品 下订单
	* 1.测试登录 账号 admin admin
	* 2.查看所有产品列表
	* 3.选第一款产品，下订单
	* 4.实现订单交易支付
	* 5.查看所有的订单信息
	*/
	@RequestMapping(value="/create",method=RequestMethod.GET)
	public List<Orders> createOrder(){
		// 测试登录
		this.login();
		return null;
	}

	/**
	* 用户登录
	*/
	private Integer login(){
		String username =  "admin";
		String password = "admin";
		User user = this.userService.login(username, password);
		if(user != null && user.getUserName().length() >= 0){
			System.out.println("登录成功");
			return user.getId();
		}
		System.out.println("登录失败");
		return null;
	}
}

访问服务

模拟登陆操作成功~

二、查询商品信息

1.e-book-product-service 处理

  pojo同样序列化，service接口提供查询所有商品的方法，具体如下

@RequestMapping("/product")
public interface ProductService {

	@RequestMapping(value="findAll",method=RequestMethod.GET)
	public List<Product> findAll();
}

2.e-book-product-provider处理

2.1 service实现

@Service
public class ProductServiceImpl {

	@Autowired
	private ProductMapper productMapper;

	public List<Product> findAll(){
		ProductExample example = new ProductExample();
		return productMapper.selectByExample(example);
	}

}

2.2 controller处理

/**
 * 商品服务  提供者
 * @author dengp
 *
 */
@RestController
public class ProductController implements ProductService{

	@Autowired
	private ProductServiceImpl service;

	@Override
	public List<Product> findAll() {

		return service.findAll();
	}

}

2.3启动类

/**
 * provider的启动类
 * @author dengp
 *
 */
@EnableEurekaClient
@SpringBootApplication
@MapperScan("com.bobo.mapper")
public class Start {

    public static void main(String[] args) {
        SpringApplication.run(Start.class, args);
    }
}

三、创建订单

1.e-book-order-service

  pojo同样需要序列化，service的接口功能如下:

@RequestMapping("/order")
public interface OrderService {

	@GetMapping("/findAll")
	public List<Orders> findAll();

	@PostMapping(value="/addOrder",consumes=MediaType.APPLICATION_JSON_VALUE)
	public Integer addOrder(@RequestBody Orders order);

}

2.e-book-order-provider

2.1 业务功能实现

@Service
public class OrderServiceImpl {

	@Autowired
	private OrdersMapper ordersMapper;

	public List<Orders> findAll(){
		OrdersExample example = new OrdersExample();
		return ordersMapper.selectByExample(example );
	}

	public Integer addOrder(Orders order){
		return ordersMapper.insertSelective(order);
	}

}

2.2 controller

/**
 * 订单服务  提供者
 * @author dengp
 *
 */
@RestController
public class OrderController implements OrderService{

	@Autowired
	private OrderServiceImpl service;

	@Override
	public List<Orders> findAll() {
		// TODO Auto-generated method stub
		return service.findAll();
	}

	@Override
	public Integer addOrder(@RequestBody Orders order) {
		// TODO Auto-generated method stub
		service.addOrder(order);
		return  order.getId();
	}

}

2.3 启动类

  注意添加注解

/**
 * provider的启动类
 * @author dengp
 *
 */
@EnableEurekaClient
@SpringBootApplication
@MapperScan("com.bobo.mapper")
public class Start {

    public static void main(String[] args) {
        SpringApplication.run(Start.class, args);
    }
}

四、完成交易

1.e-book-trade-service

@RequestMapping("/trade")
public interface TradeService {

	// 查询所有交易信息
	@RequestMapping(value = "/findAll", method = RequestMethod.GET)
	public List<Trade> findAll();

	@RequestMapping(value="/create" ,method=RequestMethod.POST
			,consumes=MediaType.APPLICATION_JSON_VALUE)
	public void addTrade(@RequestBody Trade trade);

}

2.e-book-trade-provider

2.1 业务实现

@Service
public class TradeServiceImpl {

	@Autowired
	private TradeMapper tradeMapper;

	/**
	 * 查询所有交易信息
	 */
	public List<Trade> findTradeAll() {
		TradeExample example = new TradeExample();
		return this.tradeMapper.selectByExample(example);
	}

	/**
	 * 添加交易信息
	 */
	public void addTrade(@RequestBody Trade trade) {
		this.tradeMapper.insert(trade);
	}
}

2.2 controller

@RestController
public class TradeController implements TradeService{

	@Autowired
	private TradeServiceImpl service;

	@Override
	public List<Trade> findAll() {
		// TODO Auto-generated method stub
		return service.findTradeAll();
	}

	@Override
	public void addTrade(Trade trade) {
		// 添加支付信息
		service.addTrade(trade);
	}

}

2.3 启动类

@SpringBootApplication
@EnableEurekaClient
@MapperScan("com.bobo.mapper")
public class Start {

    public static void main(String[] args) {
        SpringApplication.run(Start.class, args);
    }
}

3.consumer服务

/**
 * 创建订单
 * 
 * @author dengp
 *
 */
@RestController
public class ConsumerController {

	@Autowired
	private ConsumerOrderService orderService;

	@Autowired
	private ConsumerProductService productService;

	@Autowired
	private ConsumerTradeService tradeService;

	@Autowired
	private ConsumerUserService userService;

	/**
	 * 模拟内容： 登录 查看产品 下订单
	 *  1.测试登录 账号 admin admin 
	 *  2.查看所有产品列表 
	 *  3.选第一款产品，下订单
	 *  4.实现订单交易支付
	 *  5.查看所有的订单信息
	 */
	@RequestMapping(value = "/create", method = RequestMethod.GET)
	public List<Orders> createOrder() {
		// 测试登录 账号： 用户名：admin 密码：admin
		Integer userid = this.login();
		System.out.println(userid);
		// 查询所有商品
		List<Product> products = this.productService.findAll();
		/*
		 * for (Product product : products) {
		 * System.out.println(product.getName()); }
		 */
		// 选第一款商品 下订单
		Product product = products.get(0);
		// 创建订单
		Orders orders = new Orders();
		// 订单ID
		Integer orderId = 1011;
		orders.setId(orderId);
		orders.setUserId(userid);
		orders.setProductId(product.getId());
		orders.setPrice(product.getPrice());
		// '删除标志，默认0不删除，1删除
		orders.setDeleted((byte) 0);
		// 调用Order服务持久化订单
		Integer oId = this.orderService.addOrder(orders);
		System.out.println(oId);

		// 订单的交易支付
		Trade trade = new Trade();
		trade.setUserId(userid);
		trade.setOrderId(oId);
		trade.setPrice(orders.getPrice());
		trade.setPayStatus((byte) 4);// '1 未付款 2 付款中 3 付款失败 4 付款完成'
		trade.setPayType((byte) 4); // '支付类型:1-支付宝支付，2-网银在线，3-银联，4-微信支付',
		trade.setGatewayPayNum(new Date().getTime() + "");// '网关支付流水号',
		trade.setGatewayPayPrice(orders.getPrice());
		trade.setGatewayPayTime(new Date());
		trade.setDeleted((byte) 0);
		this.tradeService.addTrade(trade);

		// 查询所有订单并返回
		List<Orders> list = this.orderService.findAll();

		return list;
	}

	/**
	 * 用户登录
	 */
	private Integer login() {
		String username = "admin";
		String password = "admin";
		User user = this.userService.login(username, password);
		if (user != null && user.getUserName().length() >= 0) {
			System.out.println("登录成功");
			return user.getId();
		}
		System.out.println("登录失败");
		return null;
	}
}

分别启动服务测试

启动consumer服务，范围测试

创建订单成功

创建支付信息成功

五、更新订单信息

  接下来我们需要完成更新订单中的支付信息的操作，也就是e-book-trade-provider需要调用e-book-order-provider的服务。

1.修改 Trade 的 pom 文件

  添加 Order-Service、Feign 的坐标

2.修改启动类

  添加fegin的主键

@EnableFeignClients
@SpringBootApplication
@EnableEurekaClient
@MapperScan("com.bobo.mapper")
public class StartTrade {

    public static void main(String[] args) {
        SpringApplication.run(StartTrade.class, args);
    }
}

3.在 Trade-Provider 服务中添加接口

@FeignClient("e-book-order")
public interface ProviderOrderService extends OrderService{

}

4.修改 Order-Service 添加方法

	//根据订单 ID 查询订单
	@RequestMapping(value="/findOrderById",method=RequestMethod.GET)
	public Orders findOrderById(@RequestParam("orderid") Integer orderid);

	//更新订单
	@RequestMapping(value="/updateOrder",method=RequestMethod.POST
			,consumes=MediaType.APPLICATION_JSON_VALUE)
	public void updateOrder(@RequestBody Orders order);

5.修改OrderServiceImpl

  修改 Order-Provider 的 OrderServiceImpl 完成对数据库的操作

@Service
public class OrderServiceImpl {

	@Autowired
	private OrdersMapper ordersMapper;

	public List<Orders> findAll() {
		OrdersExample example = new OrdersExample();
		return ordersMapper.selectByExample(example);
	}

	public Integer addOrder(Orders order) {
		return ordersMapper.insert(order);
	}

	/**
	 * 根据 ID 查询订单
	 */
	public Orders findOrderById(Integer id) {
		return this.ordersMapper.selectByPrimaryKey(id);
	}

	/**
	 * 更新订单
	 */
	public void updateOrder(Orders order) {
		this.ordersMapper.updateByPrimaryKey(order);
	}

}

6.OrderController

/**
 * 订单服务  提供者
 * @author dengp
 *
 */
@RestController
public class OrderController implements OrderService{

	@Autowired
	private OrderServiceImpl service;

	@Override
	public List<Orders> findAll() {
		// TODO Auto-generated method stub
		return service.findAll();
	}

	@Override
	public Integer addOrder(@RequestBody Orders order) {
		// TODO Auto-generated method stub
		service.addOrder(order);
		return  order.getId();
	}

	@Override
	public Orders findOrderById(Integer orderid) {
		return this.service.findOrderById(orderid);
	}
	@Override
	public void updateOrder(@RequestBody Orders order) {
		this.service.updateOrder(order);
	}
}

6.在 Trade-provider中完成业务实现

	@Override
	public void addTrade(@RequestBody Trade trade) {
		// 添加支付信息
		service.addTrade(trade);
		//根据 ID 查询订单
		Orders order = this.providerOrderService.findOrderById(trade.getOrderId());
		System.out.println(order.getId()+" ----  "+trade.getId());
		order.setTradeId(trade.getId());
		//更新订单
		this.providerOrderService.updateOrder(order);
	}

添加这段逻辑，完成更新订单中的支付编号信息