JAVA 多用户商城系统b2b2c-eureka 实现微服务入门程序

时间 2019-12-06

标签 java 多用户商城系统 b2b2c eureka 实现微服入门程序栏目 Java 繁體版

原文原文链接

在写代码以前先了解几个概念。java

单系统架构mysql

须要JAVA Spring Cloud大型企业分布式微服务云构建的B2B2C电子商务平台源码一零三八七七四六二六nginx

将业务逻辑层、数据库访问层、控制层放入在一个项目中。优势:适合于我的或者小团队开发，不适合大团队开发。程序员

分布式项目架构web

根据业务需求进行拆分红N个子系统，多个子系统相互协做才能完成业务流程子系统之间通信使用RPC远程通信技术。优势:spring

1.把模块拆分，使用接口通讯，下降模块之间的耦合度。sql

2.把项目拆分红若干个子项目，不一样的团队负责不一样的子项目。数据库

3.增长功能时只须要再增长一个子项目，调用其它系统的接口就能够。apache

4.能够灵活的进行分布式部署。api

有优势就有缺点，缺点以下：

1.系统之间交互须要使用远程通讯，接口开发增长工做量。

2.各个模块有一些通用的业务逻辑没法共用。

为了解决上面分布式架构的缺点，咱们引入了soa架构，SOA：Service Oriented Architecture面向服务的架构。也就是把工程拆分红服务层、表现层两个工程。服务层中包含业务逻辑，只须要对外提供服务便可。表现层只须要处理和页面的交互，业务逻辑都是调用服务层的服务来实现。

什么是项目集群

多台服务器部署相同应用构成一个集群

做用：经过负载均衡设备共同对外提供服务

RPC远程调用

RPC 的全称是 Remote Procedure Call 是一种进程间通讯方式。

它容许程序调用另外一个地址空间（一般是共享网络的另外一台机器上）的过程或函数，而不用程序员显式编码这个远程调用的细节。即不管是调用本地接口/服务的仍是远程的接口/服务，本质上编写的调用代码基本相同。

好比两台服务器A，B，一个应用部署在A服务器上，想要调用B服务器上应用提供的函数或者方法，因为不在一个内存空间，不能直接调用，这时候须要经过就能够应用RPC框架的实现来解决

restful、soap、rpc

（1）restful是一种架构设计风格，提供了设计原则和约束条件，而不是架构。而知足这些约束条件和原则的应用程序或设计就是 RESTful架构或服务。

（2）soap象访问协议是一种数据交换协议规范，是一种轻量的、简单的、基于XML的协议的规范。SOAP协议和HTTP协议同样，都是底层的通讯协议，只是请求包的格式不一样而已，SOAP包是XML格式的。

soap基于xml并封装成了符合http协议，所以，它符合任何路由器、防火墙或代理服务器的要求。

soap可使用任何语言来完成，只要发送正确的soap请求便可，基于soap的服务能够在任何平台无需修改便可正常使用。

（3）RPC就是从一台机器（客户端）上经过参数传递的方式调用另外一台机器（服务器）上的一个函数或方法（能够统称为服务）并获得返回的结果。

RPC 会隐藏底层的通信细节（不须要直接处理Socket通信或Http通信）

RPC 是一个请求响应模型。客户端发起请求，服务器返回响应（相似于Http的工做方式）

RPC 在使用形式上像调用本地函数（或方法）同样去调用远程的函数（或方法）。

rpc远程调用框架

几种比较典型的RPC的实现和调用框架。

（1）RMI实现，利用java.rmi包实现，基于Java远程方法协议(Java Remote Method Protocol) 和java的原生序列化。

（2）Hessian，是一个轻量级的remoting onhttp工具，使用简单的方法提供了RMI的功能。基于HTTP协议，采用二进制编解码。

（3）thrift是一种可伸缩的跨语言服务的软件框架。thrift容许你定义一个描述文件，描述数据类型和服务接口。依据该文件，编译器方便地生成RPC客户端和服务器通讯代码。

（4）SpringCloud 为开发人员提供了快速构建分布式系统的一些工具，包括配置管理、服务发现、断路器、路由、微代理、事件总线、全局锁、决策竞选、分布式会话等等。

（4） Dubbo是阿里巴巴公司开源的一个高性能优秀的服务框架，使得应用可经过高性能的 RPC 实现服务的输出和输入功能，能够和 Spring框架无缝集成。

面向于服务架构（SOA）

业务系统分解为多个组件，让每一个组件都独立提供离散，自治，可复用的服务能力，经过服务的组合和编排来实现上层的业务流程做用：简化维护,下降总体风险,伸缩灵活

什么是微服务架构

架构设计概念,各服务间隔离（分布式也是隔离）,自治（分布式依赖总体组合）其它特性(单一职责,边界,异步通讯,独立部署)是分布式概念的跟严格执行 SOA到微服务架构的演进过程

做用：各服务可独立应用，组合服务也可系统应用(巨石应用[monolith]的简化实现策略-平台思想)

服务提供者与消费关系

服务提供者:提供服务被人调用

消费者:调用被人服务

服务的注册与发现(Eureka )

在这里，咱们须要用的的组件上Spring Cloud Netflix的Eureka ,eureka是一个服务注册和发现模块。

什么是Eureka

官方的介绍在这里Eureka wiki。Eureka是Netflix开源的一个RESTful服务，主要用于服务的注册发现。Eureka由两个组件组成：Eureka服务器和Eureka客户端。Eureka服务器用做服务注册服务器。Eureka客户端是一个java客户端，用来简化与服务器的交互、做为轮询负载均衡器，并提供服务的故障切换支持。Netflix在其生产环境中使用的是另外的客户端，它提供基于流量、资源利用率以及出错状态的加权负载均衡。

在我看来，Eureka的吸引力来源于如下几点：

开源：你们能够对实现一探究竟，甚至修改源码。

可靠：通过Netflix多年的生产环境考验，使用应该比较靠谱省心

功能齐全：不但提供了完整的注册发现服务，还有Ribbon等能够配合使用的服务。

基于Java：对于Java程序员来讲，使用起来，内心比较有底。

Spring Cloud,与Eureka进行了很好的集成，使用起来很是方便。

代码实现

Eureka服务端，代码结构以下：

EurekaApplication.java

package com.example.eureka;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer //这个注释必定要加 eureka服务端
public class EurekaApplication {

    public static void main(String[] args) {
        SpringApplication.run(EurekaApplication.class, args);
    }
}
复制代码

application.yml

server:
  port: 8888
eureka:
  instance:
    hostname: localhost
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
      #eureka 访问地址为 http://localhost:8888
复制代码

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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>

    <groupId>com.example</groupId>
    <artifactId>service-member</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>service-member</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>
复制代码

启动 EurekaApplication.java

访问http://localhost:8888，如图：

因为没有如今尚未服务注册进来，因此实例为空。

下面咱们写个服务注册到eureka上面：

代码结构以下图：

MemberController.java

package com.example.controller;

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

import java.util.ArrayList;
import java.util.List;

@RestController
public class MemberController {
    @Value("${server.port}")
    private String port; //port 参数用来测试 当这个服务启动多个的时候 客户端访问的时候采用轮询的方式

    @RequestMapping("/getUser")
    public List getUser(){
        List list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add(port);
        return list;
    }
}
复制代码

ServiceMemberApplication.java

package com.example.servicemember;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
@EnableEurekaClient //eureka 客户端
@ComponentScan("com.example.controller")//扫描包
public class ServiceMemberApplication {

    public static void main(String[] args) {
        SpringApplication.run(ServiceMemberApplication.class, args);
    }
}
复制代码

application.yml

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8888/eureka/
      #将服务注册到上面的地址
server:
  port: 8762
spring:
  application:
    name: service-member
复制代码

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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>

    <groupId>com.example</groupId>
    <artifactId>service-member</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>service-member</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Finchley.M9</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>


</project>
复制代码

启动ServiceMemberApplication.java ，启动完毕，这时候这个服务就被注册到eureka中了。打开http://localhost:8888/，如图：

如图，服务被注册进来了。

接下来，写一个调用SERVICE-MEMBER服务的服务，即消费者服务。

项目结构以下图：

OrderController.java

package com.example.controller;

import com.example.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class OrderController {
    @Autowired
    private OrderService orderService;

    @RequestMapping("/getUser")
    public List<String> getUser(){
        return orderService.getMember();
    }



}
复制代码

OrderService.java

package com.example.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@Service
public class OrderService {
    @Autowired
    private RestTemplate restTemplate;

    public List<String> getMember(){
        return restTemplate.getForObject("http://service-member/getUser",List.class);
    }
}
复制代码

ServiceOrderApplication.java

package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@EnableEurekaClient
@SpringBootApplication
public class ServiceOrderApplication {

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

    @Bean
    @LoadBalanced //ribbon实现负载均衡，须要加入ribbon依赖
    RestTemplate restTemplate() {
        return new RestTemplate();
    }
}
复制代码

application.yml

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8888/eureka/
      #将该服务注册到上面地址的eureka中
server:
  port: 8764
  tomcat:
    max-threads: 50
spring:
  application:
    name: service-order
复制代码

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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>

    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.10.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>
复制代码

好了，启动ServiceOrderApplication ，再打开http://localhost:8888/ 会发现又多了一个服务，以下图：

咱们访问getUser这个接口，获得结果：如图：

这样咱们一个简单的微服务就写完了。

咱们能够将服务提供者service-member的端口改掉，如今是8762，咱们将端口改成8763，再启动一下service-member，以前启动的8762不要停，如今至关于service-member这个服务有两个。再刷新一下http://localhost:8888/ 这个地址，发现service-member变成了两个。以下图：

这是咱们重复的去访问getUser这个接口，发现返回的port这个参数在8762和8763之间来回切换，这个就说明是对service-member服务的轮询访问。

zuul拦截

Zuul的主要功能是路由转发和过滤器。路由功能是微服务的一部分，好比／api/user转发到到user服务，/api/shop转发到到shop服务。zuul默认和Ribbon结合实现了负载均衡的功能，相似于nginx转发。

新建一个工程用来实现zuul转发功能。

项目结构以下图：

依赖：pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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>

    <groupId>com.example</groupId>
    <artifactId>service-zuul</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>service-zuul</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Finchley.RC1</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>


</project>
复制代码

ServiceZuulApplication.java

package com.example.servicezuul;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

@EnableZuulProxy //必需要加这个注解
@EnableEurekaClient
@SpringBootApplication
public class ServiceZuulApplication {

    public static void main(String[] args) {
        SpringApplication.run(ServiceZuulApplication.class, args);
    }
}
复制代码

application.yml

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8888/eureka/
server:
  port: 8769
spring:
  application:
    name: service-zuul
zuul:
  routes:
    api-a:
      path: /api-member/**
      #path自定义便可
      service-id: service-member 
      #service-id是对应得服务工程名,这里表示访问/api-member/** 会转发到service-member这个服务
    api-b:
      path: /api-order/**
      service-id: service-order
复制代码

以上，zuul转发就配置好了，当访问http://localhost:8769/api-member/getUser 是就会转发到service-member这个服务的getUser接口。

ZuulFilter拦截器

对全部请求进行拦截过滤，新建拦截器，MyFilter.java

package com.example.servicezuul;

import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import com.netflix.zuul.exception.ZuulException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
@Component
public class MyFilter extends ZuulFilter {
    private static Logger logger = LoggerFactory.getLogger(MyFilter.class);

    /**
     * filterType：返回一个字符串表明过滤器的类型，在zuul中定义了四种不一样生命周期的过滤器类型，具体以下：
     * pre：能够在请求被路由以前调用
     * route：在路由请求时候被调用
     * post：在route和error过滤器以后被调用
     * error：处理请求时发生错误时被调用
     * @return
     */
    @Override
    public String filterType() {
        return "pre";// 前置过滤器
    }

    /**
     * filterOrder：经过int值来定义过滤器的执行顺序
     * @return
     */
    @Override
    public int filterOrder() {
        return 0;// 优先级为0，数字越大，优先级越低
    }

    /**
     * shouldFilter：返回一个boolean类型来判断该过滤器是否要执行，因此经过此函数可实现过滤器的开关。在上例中，咱们直接返回true，因此该过滤器老是生效
     * @return
     */
    @Override
    public boolean shouldFilter() {
        return true;// 是否执行该过滤器，此处为true，说明须要过滤
    }

    /**
     * run：过滤器的具体逻辑。须要注意，这里咱们经过ctx.setSendZuulResponse(false)令zuul过滤该请求，不对其进行路由，而后经过ctx.setResponseStatusCode(401)设置了其返回的错误码
     * @return
     * @throws ZuulException
     */
    @Override
    public Object run() throws ZuulException {
        RequestContext ctx = RequestContext.getCurrentContext();
        HttpServletRequest request = ctx.getRequest();
        logger.info(String.format("%s >>> %s", request.getMethod(), request.getRequestURL().toString()));
        String refer=request.getHeader("refer");
        Object accessToken = request.getParameter("token");
        if (accessToken != null) {
            return null;
        }
        logger.warn("token is empty");
        ctx.setSendZuulResponse(false);//过滤该请求，不对其进行路由
        ctx.setResponseStatusCode(401);
        try {
            ctx.getResponse().getWriter().write("token is empty");
        } catch (Exception e) {
        }
        return null;
    }

    public static void main(String[] args) {
        logger.info(String.format("%s >>> %s", "jiangjz", "www.baidu.con"));
    }
}
复制代码

java B2B2C Springcloud多租户电子商城系统