Springcloud微服务搭建(springboot+springcloud+lcn分布式事物)

最新推荐文章于 2024-08-31 03:15:00 发布
置顶 最新推荐文章于 2024-08-31 03:15:00 发布
阅读量2.3k 收藏 13
点赞数 4
文章标签： springboot springcloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/everythingatonce/article/details/84990308
版权

 

单体架构：

        起初的web服务都是单体架构，不管多少个模块都在一个项目里面，随着项目模块越来越多，客户量的不断增长，导致系统的负重越来越大，模块达不到高可用，扩展性差，无法满足并发的要求等问题亟待解决。所以引出微服务架构。

微服务架构：

         微服务架构就是把单体架构的应用的不同功能拆分成一系列小的web服务，这些小的web服务可以拥有自己私有的数据持久化业务数据，服务之间可独立部署，通过各自暴露的api接口相互通讯，最终构成一个完整的web应用，实现了高内聚、低耦合的功能。

微服务架构特性和优点：

  1. 单一原则，每个模块可以独立部署，每个服务可独立运行在自己的进程里。
  2. 一系列单独的微服务共同构建了整个系统，微服务可以再进行水平扩展。
  3. 每个服务为独立的业务开发，一个微服务只关注其特定的某个功能、松耦合。
  4. 高可用，因为是微服务，其中某些共同的服务就可以复用，比如用户服务、日志服务等开发一套，其他项目需要用只需做少量的调整就可以，避免重复造轮子
  5. 技术栈多元化，可以使用不同的语言（C++,python等）和不同的数据存储技术（mysql、orcale等）进行开发。
  6. 微服务之间可以通过一些轻量级的通信机制进行通讯，例如通过REST API调用。

微服务的缺点：

  1. 运维成本高。
  2. 分布式服务的复杂性、例如分布式事物等。
  3. 接口调整成本较高，因为服务之间都是通过http进行调用，接口做了改动，调用此接口的微服务可能会受到影响。

项目中暂时用的是Dubbo，对dubbo研究的不是很深入，本次就微服务框架Dubbo、SpringCloud进行简单的总结：

Dubbo:

         Dubbo是阿里巴巴SOA（面向服务架构）服务化治理方案的开源框架。它是基于RPC远程服务调用方案，是基于zookeeper实现服务注册与发现。

Springboot+dubbo+zookeeper:

它的使用方法很简单，引入相关jar包，加上几个注解和少量的配置即可。它的项目代码结构分为以下几个

1.common-api: 提供统一的interface接口，最终会打为jar包，供consumer和provider引用项目的公共基础包，一般包含entity、service接口和工具类。

2.user-provider:用户服务，项目的用户登录等基础的用户接口具体实现类，其中包含

dao、service实现类。

3.common-c:项目的api接口统一入口，web页面只调用此模块进行后台服务访问。

项目搭建详见博客：https://blog.csdn.net/qq_21144985/article/details/79413163

SpringCloud：

         SpringCloud是基于springboot之上的用来快速构建微服务系统的工具集、拥有诸多完整的微服务组件，像Eureka服务注册中心、Feign声明式rest调用客户端负载均衡Ribbon、Hystrix服务容错、Zuul服务网关、Spring Cloud Config配置中心、Sleuth服务跟踪等组件。利用这些组件可以快速搭建一套微服务系统，利于人们开发。

分布式事物：

         因为使用了微服务框架，服务拥有自己独立的数据库，当A服务的方法a调用B服务的方法b，A和B都操作了自己的数据库， 此时如果先执行了b，然后执行a的时候发生异常，此时b方法中的执行成功事物已提交，只会回滚a方法中的数据，这样就破坏了事物的原子性。为了保持事物的ACID原则，保证数据的一致性，就需要用到分布式事物。

LCN：

         lcn实际上是把多个分布式事物统一管理起来形成一个事务组，最终对这个事务组进行维护来判断事物是否都提交成功。通过@TxTransaction注解即可实现分布式事物，对代码侵入低。

LCN官网http://www.txlcn.org/ 

LCN框架原理介绍：https://blog.csdn.net/gududedabai/article/details/83012487

 

TCC：

        TCC 将事务提交分为 Try - Confirm - Cancel 3个操作。Try：预留业务资源/数据效验、Confirm：确认执行业务操作、Cancel：取消执行业务操作。是基于两段式提交的，对代码侵入强，编码成本高。详细介绍：https://www.liangzl.com/get-article-detail-525.html

 

以下介绍IDEA如何搭建Springboot + springcloud微服务项目：

  • 创建Maven多模块项目

1.File →new →project  选择Spring Initializr   点击Next到以下页面

然后Next 一直到最后点击Finish完成父项目模块

 

 

2.创建eureka-server模块 项目右键> New > Module 选择spring initalizr

 

Group：一般是域名的反写，我这里是com.iking

Artifact:模块名称 随便写，最好是便于理解的名称 此处是eureka-server

然后点击下一步，最后Finish:

3.创建common-module模块，项目的公共依赖模块，一般包含entity、util工具类等，最终以jar包的形式引入到其他服务模块。创建方法同上只需把Artifact填写成common-module即可

4.创建业务模块user-service、order-service

5.创建微服务网关api-gateway

最终的项目结构如下

删除每个子模块中没用的文件，.mvn、.gitignore、daoiml、mvnw、mvnw.cmd文件

此时微服务项目的结构已经创建完毕，现在开始编码

1.首先更改父级pom文件

<?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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.iking</groupId>
    <artifactId>spring-cloud</artifactId>
    <packaging>pom</packaging>
    <version>1.0.0</version>
    <name>spring-cloud</name>
    <!--声明有多少个子模块-->
    <modules>
        <module>eureka-server</module>
        <module>api-gateway</module>
        <module>order-service</module>
        <module>user-service</module>
    </modules>
    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <!--spring boot 应用关闭的前提配置 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <!--eureka服务依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-feign</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-hystrix</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-hystrix-dashboard</artifactId>
        </dependency>
        <!-- json-lib -->
        <dependency>
            <groupId>net.sf.json-lib</groupId>
            <artifactId>json-lib</artifactId>
            <version>2.4</version>
            <classifier>jdk15</classifier>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.44</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>ch.qos.logback</groupId>
                    <artifactId>logback-classic</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
   
        <!-- 集成 Swagger -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.6.1</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.6.1</version>
        </dependency>

    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Dalston.RC1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <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>

 

2.common-module pom文件

<?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.iking</groupId>
    <artifactId>common-module</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>
    <name>common-module</name>
    <parent>
        <groupId>com.iking</groupId>
        <artifactId>spring-cloud</artifactId>
        <version>1.0.0</version>
    </parent>
</project>

 

代码结构：

 

3.api-gateway pom文件

<?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.iking</groupId>
    <artifactId>api-gateway</artifactId>
    <version>1.0.0</version>
    <name>api-gateway</name>
    <!--***声明父级依赖-->
    <parent>
        <groupId>com.iking</groupId>
        <artifactId>spring-cloud</artifactId>
        <version>1.0.0</version>
    </parent>
    <dependencies>
        <!--***项目公共模块依赖-->
        <dependency>
            <groupId>com.iking</groupId>
            <artifactId>common-module</artifactId>
            <version>1.0.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zuul</artifactId>
        </dependency>
        <dependency>
            <groupId>commons-httpclient</groupId>
            <artifactId>commons-httpclient</artifactId>
            <version>3.1</version>
        </dependency>
        <!--zipkin-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-sleuth</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zipkin</artifactId>
        </dependency>
        <!--commons-io -->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.6</version>
        </dependency>
    </dependencies>
</project>

application.properties文件

server.port=8013
spring.application.name=api-getway:
eureka.client.service-url.defaultZone=http://127.0.0.1:8761/eureka/
eureka.instance.ip-address=true
#网关超时时间配置
zuul.host.socket-timeout-millis=600000
zuul.host.connect-timeout-millis=10000
hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds=600000
#ribbon.ConnectTimeout=3000
#ribbon.ReadTimeout=60000
spring.zipkin.base-url=http://localhost:9411
spring.sleuth.sampler.percentage=1.0

ApiGatewayApplication启动类


import com.netflix.zuul.ZuulFilter;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;
import springfox.documentation.swagger.web.SwaggerResource;
import springfox.documentation.swagger.web.SwaggerResourcesProvider;

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


@EnableZuulProxy
@SpringBootApplication
public class ApiGatewayApplication {

    public static void main(String[] args) {
        SpringApplication.run(ApiGatewayApplication.class, args);
    }
    @Component
    @Primary
    class DocumentationConfig implements SwaggerResourcesProvider {

        @Override
        public List<SwaggerResource> get() {
            List resources = new ArrayList();
            resources.add(swaggerResource("用户服务Api","/user-service/v2/api-docs","2.0"));
            resources.add(swaggerResource("订单服务Api","/order-service/v2/api-docs","2.0"));
            return resources;
        }

        private SwaggerResource swaggerResource(String name, String location, String version) {
            SwaggerResource swaggerResource = new SwaggerResource();
            swaggerResource.setName(name);
            swaggerResource.setLocation(location);
            swaggerResource.setSwaggerVersion(version);
            return swaggerResource;
        }
    }

}

代码结构：

 

4.eureka-server pom文件

<?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.iking</groupId>
    <artifactId>eureka-server</artifactId>
    <version>1.0.0</version>
    <name>eureka-server</name>
    <description>Demo project for Spring Boot</description>

    <!--声明父级依赖-->
    <parent>
        <groupId>com.iking</groupId>
        <artifactId>spring-cloud</artifactId>
        <version>1.0.0</version>
    </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.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka-server</artifactId>
        </dependency>
    </dependencies>
</project>

EurekaServerApplication启动类:

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

@EnableEurekaServer
@SpringBootApplication
public class EurekaServerApplication {

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

}

application.properties文件：

server.port=8761
eureka.client.service-url.defaultZone=http://localhost:${server.port}/eureka/
spring.application.name=eureka-server
eureka.server.enable-self-preservation=false

 

 

5.user-service pom文件

<?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.iking</groupId>
    <artifactId>user-service</artifactId>
    <version>1.0.0</version>
    <name>user-service</name>

    <!--声明父级依赖-->
    <parent>
        <groupId>com.iking</groupId>
        <artifactId>spring-cloud</artifactId>
        <version>1.0.0</version>
    </parent>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <lcn.last.version>4.1.0</lcn.last.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>com.iking</groupId>
            <artifactId>common-module</artifactId>
            <version>1.0.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-sleuth</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zipkin</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-feign</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.2.0</version>
        </dependency>

        <!-- 数据库连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.26</version>
        </dependency>
        <!--lcn分布式事物-->
        <dependency>
            <groupId>com.codingapi</groupId>
            <artifactId>transaction-springcloud</artifactId>
            <version>${lcn.last.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>*</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>com.codingapi</groupId>
            <artifactId>tx-plugins-db</artifactId>
            <version>${lcn.last.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>*</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>false</filtering>
                <includes>
                    <include>**/*</include>
                </includes>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <mainClass>com.iking.userservice.UserServiceApplication</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

application.properties文件

server.port=8011
eureka.client.service-url.defaultZone=http://127.0.0.1:8761/eureka/
spring.application.name=user-service

server.session-timeout=30
server.context-path=
server.tomcat.max-threads=100
server.tomcat.uri-encoding=UTF-8

# DATASOURCE
spring.datasource.platform=mysql
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.url=jdbc:mysql://localhost:3306/sc_project1?characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.max-active=100
spring.datasource.max-idle=2
spring.datasource.min-idle=1
spring.datasource.initial-size=15
spring.jmx.enabled = false
#security auth
security.basic.enabled=false
security.user.name=user
security.user.password=user
security.sessions=stateless

#mybatis
mybatis.mapperLocations=classpath*:com/iking/userservice/mapping/*.xml
mybatis.typeAliasesPackage=com.iking.userservice.*

#multipart file
spring.http.multipart.maxFileSize=1000Mb
spring.http.multipart.maxRequestSize=1000Mb

#Ribbon的负载均衡策略
#ribbon.NFLoadBalancerRuleClassName=com.netflix.loadbalancer.RandomRule
#ribbon.MaxAutoRetriesNextServer=0
#txmanager地址
tm.manager.url=http://127.0.0.1:8899/tx/manager/

logging.level.com.codingapi=debug

spring.zipkin.base-url=http://localhost:9411
spring.sleuth.sampler.percentage=1.0
#//开启健康检查（需要spring-boot-starter-actuator依赖）
eureka.client.healthcheck.enabled = true
#租期更新时间间隔（默认30秒）
eureka.instance.lease-renewal-interval-in-seconds =10
#租期到期时间（默认90秒）
eureka.instance.lease-expiration-duration-in-seconds =30

UserServiceApplication启动类：

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
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.feign.EnableFeignClients;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;
import org.springframework.cloud.netflix.hystrix.dashboard.EnableHystrixDashboard;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.core.env.Environment;
import org.springframework.web.client.RestTemplate;

import javax.sql.DataSource;


@EnableFeignClients
@EnableEurekaClient
@EnableHystrixDashboard
@SpringBootApplication
@ComponentScan(basePackages = { "com.iking"})
@EnableHystrix
@EnableAutoConfiguration
public class UserServiceApplication {

    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
    @LoadBalanced
    @Bean
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
    //lcn分布式事物需要的代码块
    @Autowired
    private Environment env;
    @Bean
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(env.getProperty("spring.datasource.url"));
        dataSource.setUsername(env.getProperty("spring.datasource.username"));//用户名
        dataSource.setPassword(env.getProperty("spring.datasource.password"));//密码
        dataSource.setInitialSize(2);
        dataSource.setMaxActive(20);
        dataSource.setMinIdle(0);
        dataSource.setMaxWait(60000);
        dataSource.setValidationQuery("SELECT 1");
        dataSource.setTestOnBorrow(false);
        dataSource.setTestWhileIdle(true);
        dataSource.setPoolPreparedStatements(false);
        return dataSource;
    }
}

代码结构

 

 

6.order-service pom文件

<?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.iking</groupId>
    <artifactId>order-service</artifactId>
    <version>1.0.0</version>
    <name>order-service</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <maven.compile.source>1.8</maven.compile.source>
        <maven.compile.target>1.8</maven.compile.target>
        <lcn.last.version>4.1.0</lcn.last.version>
    </properties>
    <!--声明父级依赖-->
    <parent>
        <groupId>com.iking</groupId>
        <artifactId>spring-cloud</artifactId>
        <version>1.0.0</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>com.iking</groupId>
            <artifactId>common-module</artifactId>
            <version>1.0.0</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.2.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-sleuth</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zipkin</artifactId>
        </dependency>

        <!-- 数据库连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.26</version>
        </dependency>
        <!--lcn分布式事物-->
        <dependency>
            <groupId>com.codingapi</groupId>
            <artifactId>transaction-springcloud</artifactId>
            <version>${lcn.last.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>*</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>com.codingapi</groupId>
            <artifactId>tx-plugins-db</artifactId>
            <version>${lcn.last.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>*</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <resources>
            <!-- maven项目中src源代码下的xml等资源文件编译进classes文件夹，
              注意：如果没有这个，它会自动搜索resources下是否有mapper.xml文件，
              如果没有就会报org.apache.ibatis.binding.BindingException: Invalid bound statement (not found): com.pet.mapper.PetMapper.selectByPrimaryKey-->
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>false</filtering>
                <includes>
                    <include>**/*</include>
                </includes>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>${maven-compiler-plugin.version}</version>
                <configuration>
                    <source>${maven.compile.source}</source>
                    <target>${maven.compile.target}</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <mainClass>com.iking.order.OrderService_Application</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

 

application.properties文件

#server.port=${random.int[1000,9999]}
server.port=8015
eureka.client.service-url.defaultZone=http://127.0.0.1:8761/eureka/
spring.application.name=order-service

server.session-timeout=30
server.context-path=
server.tomcat.max-threads=100
server.tomcat.uri-encoding=UTF-8

# DATASOURCE
spring.datasource.platform=mysql
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.url=jdbc:mysql://localhost:3306/sc_project?characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.max-active=100
spring.datasource.max-idle=2
spring.datasource.min-idle=1
spring.datasource.initial-size=15
spring.jmx.enabled = false
#security 安全认证
security.basic.enabled=false
security.user.name=order
security.user.password=order
security.sessions=stateless

#mybatis
mybatis.mapperLocations=classpath*:com/iking/orderservice/mapping/*.xml
mybatis.typeAliasesPackage=com.iking.orderservice.*

#multipart file
spring.http.multipart.maxFileSize=1000Mb
spring.http.multipart.maxRequestSize=1000Mb
#Ribbon的负载均衡策略
#ribbon.NFLoadBalancerRuleClassName=com.netflix.loadbalancer.RandomRule
#ribbon.MaxAutoRetriesNextServer=0
#txmanager地址
tm.manager.url=http://127.0.0.1:8899/tx/manager/

logging.level.com.codingapi=debug
#sleuth微服务跟踪
spring.zipkin.base-url=http://localhost:9411
spring.sleuth.sampler.percentage=1.0

Orderservice_Application启动类:

package com.iking.order;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.feign.EnableFeignClients;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;
import org.springframework.cloud.netflix.hystrix.dashboard.EnableHystrixDashboard;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.core.env.Environment;

import javax.sql.DataSource;

@EnableFeignClients
@EnableEurekaClient
@SpringBootApplication
@ComponentScan(basePackages = { "com.iking"})
@EnableHystrixDashboard
@EnableHystrix
@EnableAutoConfiguration
public class OrderService_Application {

    public static void main(String[] args) {
        SpringApplication.run(OrderService_Application.class, args);
    }
    //lcn分布式事物所需代码块
    @Autowired
    private Environment env;
    @Bean
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(env.getProperty("spring.datasource.url"));
        dataSource.setUsername(env.getProperty("spring.datasource.username"));//用户名
        dataSource.setPassword(env.getProperty("spring.datasource.password"));//密码
        dataSource.setInitialSize(10);
        dataSource.setMaxActive(50);
        dataSource.setMinIdle(0);
        dataSource.setMaxWait(60000);
        dataSource.setValidationQuery("SELECT 1");
        dataSource.setTestOnBorrow(false);
        dataSource.setTestWhileIdle(true);
        dataSource.setPoolPreparedStatements(false);
        return dataSource;
    }
}

 

代码结构：

 

 

如果项目需要服务跟踪模块 则需要单独搭建ZipkinServer服务，并且在相应微服务模块的application.properties文件中加入一下配置

#sleuth微服务跟踪
spring.zipkin.base-url=http://localhost:9411
spring.sleuth.sampler.percentage=1.0

pom文件中加入以下依赖

<!--zipkin-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-sleuth</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zipkin</artifactId>
        </dependency>

 

搭建ZipkinServer

  • 创建一个springboot项目 在pom文件中加入以下依赖

        

        <dependency>
            <groupId>io.zipkin.java</groupId>
            <artifactId>zipkin-autoconfigure-ui</artifactId>
        </dependency>
        <dependency>
            <groupId>io.zipkin.java</groupId>
            <artifactId>zipkin-server</artifactId>
        </dependency>
  • 修改启动类 使用@EnableZipkinServer注解，声明一个Zipkin Server
@EnableZipkinServer
@SpringBootApplication
public class Sc_zipkin_server_Application {
    public static void main(String[] args) {
        SpringApplication.run(Sc_zipkin_server_Application.class, args);
    }
}
  • 修改配置文件application.properties文件
server.port=9411

启动boot类 然后访问http://localhost:9411/ 即可看到以下页面

 

当微服务中配置了ZipkinServer时 访问微服务中的api接口 就会在上述页面中看到服务监控信息

 

总结：

api-gateway：此服务是zuul微服务网关，他的核心就是一系列的过滤器，可以用此服务完成身份认真与安全、动态路由、负载分配等功能。

common-module: 公共模块包，已jar包的方式加入其它微服务。

eureka-server：服务注册中心，因为LCN使用的就是eureka 所以此模块可以不要，直接使用LCN分布式事物的eureka服务。

order-service、user-service 一系列的业务微服务。

上述项目中通过zuul整合了swagger，所以项目启动成功后 可以访问http://localhost:8013/swagger-ui.html#/ 通过切换微服务，就可以访问不同的api接口

 

至此springboot整合cloud完毕，项目中因为需要用到分布式事物，所以整合了LCN分布式事物框架。

springboot版本1.5.2

springcloud版本Dalston.RC1

LCN：tx-manager-4.1.0

 

以上就是笔者对微服务项目的简单介绍，如有错误的地方，欢迎大家指出。项目源码已上传到github。

项目源码地址：

https://github.com/tanjiawei1199/spring-cloud

 

Memory_2020
关注
使用springboot、springcloud构建微服务
qw3558089的博客
06-13 820
1个弹簧引导1.1 srping-boot 简介Spring Boot 是由Pivotal 团队提供的全新框架，其设计目的是用来简化新Spring 应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot 致力于在蓬勃发展的快速应用开发领域（快速应用开发）成为领导者。1.1 Spring Boot 特点创建独立的春天...
SpringBoot,SpringCloud构建微服务在此基础快速开发
04-21
本项目实现分布式配置、服务注册与发现、消费者调用服务提供者提供的查询用户服务、代码生成器、日志AOP，下载该项目就可以快速开发基于spring boot spring cloud技术开发微服务项目了
Spring Boot + Spring Cloud 构建微服务系统（一）：服务注册和发现（Consul）
朝雨忆轻尘
10-16 317
使用Consul提供注册和发现服务 什么是 Consul Consul 是 HashiCorp 公司推出的开源工具，用于实现分布式系统的服务发现与配置。与其它分布式服务注册与发现的方案，Consul 的方案更“一站式”，内置了服务注册与发现框架、分布一致性协议实现、健康检查、Key/Value 存储、多数据中心方案，不再需要依赖其它工具（比如 ZooKeeper 等）。使用起来也较为简单。Co...
SpringCloudAlibaba基础八 微服务网关Gateway组件
最新发布
东风麦芽糖
08-31 726
Gateway高可用、Gateway全局过滤器、gateway解决跨域、gateway整合Sentinel实现熔断降级、gateway自定义断言的实现
SpringCloud搭建分布式服务架构(通俗易懂，步骤清晰)（转载）
jianye33的博客
09-02 872
问题引入：什么是SpringCloud？(在了解这个之前需要有微服务的概念) 基于springBoot的一套实现微服务的框架，提供了微服务所需的配置管理，基于Http协议的restful风格（返回异步数据） SpringCould组件架构图 在这里插入图片描述 由于在一台电脑上演示分布式项目，需要创建多个项目模块 步骤： 创建父类工程maven工程，修改pom文件，将打包方式改为pom 创建服务工程（注册中心）SpringBoot模块，选择需要导入的包，具体见下截图 在这里插入图片描述 在这里插入图片描述
使用springCloud构建微服务实战
jiankang66的博客
05-11 665
Eureka是开源的服务发现组件，本身是一个基于REST的服务。包含两个组件：Eureka Server和Eureka Client。 （1）Eureka Server提供服务发现的能力，各个微服务启动时，会向Eureka Server注册自己的信息，它会存储这些信息。 （2）Eureka Client是一个java客户端，用于简化与Eureka Server的交互。 一、创建服务发现组件（...
springboot + dubbo + LCN分布式事务 demo
10-28
【标题】"springboot + dubbo + LCN分布式事务 demo"是一个综合性的项目实例，旨在展示如何在SpringBoot框架中整合Dubbo服务治理和LCN（Local Call Notification）分布式事务解决方案，以实现高可用、高性能的分布式...
基于springCloud2.0搭建lcn解决分布式事务
05-12
总结，基于Spring Cloud 2.0搭建的LCN分布式事务解决方案，为微服务架构提供了简单且高效的事务管理手段，适用于各种复杂的业务场景。理解其原理并正确实施，能够显著提升分布式系统的稳定性和数据一致性。
spring-cloud-learning:Springcloud + rabbitmq + kafka + slueth + zipkin + lcn + redis
03-22
Spring Cloud 是一个全面的微服务解决方案，它集成了多种开源工具和服务，以帮助开发者快速创建、部署和管理分布式系统。本项目"spring-cloud-learning:Springcloud + rabbitmq + kafka + slueth + zipkin + lcn + ...
springcloud+lcn.zip
03-14
SpringCloud是中国电信天翼云开发的分布式事务解决方案——Local Connection Network（LCN）与Spring Cloud集成的项目。这个压缩包“springcloud+lcn.zip”包含了使用Spring Cloud构建微服务架构时，采用LCN进行...
springcloud2.0.4+LCN
11-30
前者是LCN的SpringCloud整合示例，后者则是一个简单的微服务应用，展示了如何在SpringCloud环境中使用LCN进行分布式事务处理。此外，`tx-plugins-db`和`tx-client`分别提供了数据库插件和LCN客户端，它们是LCN核心...
Spring Cloud微服务事务处理Demo
12-28
使用Spring Cloud微服务架构 阿里巴巴开源Seate处理分布式程序事务一致性问题demo 使用IDEA开发
springcloud分布式事务_springcloud整合分布式事务框架LCN
weixin_39855658的博客
11-25 175
TX-LCN 主要有两个模块，Tx-Client(TC) Tx-Manager(TM). TC作为微服务下的依赖，TM是独立的服务。LCN原理如下 创建事务组是指在事务发起方开始执行业务代码之前先调用TxManager创建事务组对象，然后拿到事务标示GroupId的过程。 加入事务组添加事务组是指参与方在执行完业务方法以后，将该模块的事务信息通知给TxManager的操作。 通知事务组是指在发起方...
基于SpringCloud+SpringBoot搭建分布式框架（一）
喜欢历史的码农
04-21 5702
关于搭建springcloud + springboot 的分布式项目框架 一 、 整体架构设计，如下： 具体划分为： 1. 前台用户功能： portal - provider 服务提供者 portal - consumer 服务消费者 2. 后台管理功能： manager-provider 服务提供者 manager-consumer 服务消费...
springcloud整合分布式事务框架TX-LCN
华夏指挥官的博客
04-16 866
springcloud整合分布式事务框架TX-LCN 作者小结：最近一直在搞分布式，整合分布式事务框架LCN遇到一大堆的坑，并且网上文档少之又少，费劲九牛二虎之力终于搞定，特此分享，希望对看到的朋友有所帮助！ 搭建springcloud项目 开发环境：jdk1.8、idea2019.3、maven3.6.1 、mysql、redis 请先配置好开发环境 创建maven父工程，命名为 ：sp...
Spring Cloud（一）：使用Spring Boot构建微服务
weixin_30849591的博客
06-16 179
　　Spring Cloud是在Spring Boot的基础上构建的，用于简化分布式系统构建的工具集，在使用Spring Cloud之前，首先需要掌握如何使用Spring Boot构建微服务。 一、使用官网的代码生成器来构建项目 　　官网地址：https://start.spring.io/ 　　 　　选择Maven方式构建，语言选择Java，并选择合适的Spring Boot版本，输入自...
浅谈SpringCloud微服务下分布式事务框架TX-LCN
xuzhaoa的博客
04-29 1346
浅谈SpringCloud微服务下分布式事务框架TX-LCN 传统事务的基本特性（ACID） mysql中，我们可以使用begin开始事务，rollback回滚事务，commit提交事务 redolog 记录变更、undolog回滚 Spring中，使用@Transaction标记事务 原子性（Atomic） 要么全部成功，要么全部失败，没有中间状态 一致性（Consistency） 指的是在执行...
SpringCloud分布式微服务基本构建
Lan_____的博客
11-16 510
搭建微服务需要知道SpringCloud的常用组件，以及这些组件之间的关系、用法、注意事项。比如：需要导入什么依赖、怎么配置yml文件......
org.springframework.cloud:spring-cloud-starter-netflix-eureka-server:jar is missing
热门推荐
mischen520的博客
06-02 2万+
pom.xml添加配置失败 pom.xml的核心配置如下： <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.0.0...
SpringCloud LCN事务管理：实现分布式ACID与配置教程
Spring Cloud 事务管理中的LCN事务是针对分布式系统中复杂事务处理的一种解决方案。它在Spring Cloud架构中引入了一个新的服务组件，即tx-manager，用于协调跨服务的分布式事务。LCN事务的核心目标是实现ACID...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Memory_2020

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值