精华内容
下载资源
问答
  • 搭建微服务项目

    2020-06-04 23:19:57
    1、在gitee中搭建项目 2、将项目导入idea 将gitee地址克隆写入到URL 创建模块 最后 finish就创建好了。 将模块中的pom文件复制一个到模块外面中,进行修改,只留图中这些依赖,其他都不要 ...

    1、在gitee中搭建项目

    2、将项目导入idea

    将gitee地址克隆写入到URL

    创建模块

     

     

     

     

    最后 finish就创建好了。

    将模块中的pom文件复制一个到模块外面中,进行修改,只留图中这些依赖,其他都不要

    设置最外层的.gitigore文件, 增加以下内容

    #任意路径下的mvnw,mvnw.cmd,.mvn文件
    **/mvnw
    **/mvnw.cmd
    **/.gitignore
    
    **/.mvn
    #任意路径下的target文件夹下的文件内容
    **/target/
    #同级目录下的.idea文件
    .idea
    

    提交项目初始化到gitee;

    数据库设置:utf8mb4---》可以兼容utf8并能解决一些乱码问题

     

     

    展开全文
  • 搭建微服务项目.doc

    2020-03-13 15:29:51
    搭建微服务项目(eureka、Feign、公共模块),搭建eureka、服务消费者、服务提供者、基础框架
  • 使用maven搭建微服务项目 如图为基于maven搭建的 微服务springboot多模块项目经典模式图 图中,“父模块”聚合了多个子模块,包括api、model、及server模块(当然在实际项目中可以有更多的模块,而且模块的命名可以...

    如图为基于maven搭建的 微服务springboot多模块项目经典模式图
    在这里插入图片描述
    图中,“父模块”聚合了多个子模块,包括api、model、及server模块(当然在实际项目中可以有更多的模块,而且模块的命名可以有所不同)。这三个模块的依赖层级关系是:server依赖model,model依赖api,最终构成了典型的Maven聚合型多模块项目。

    SpringBoot项目搭建流程

    打开IDEA开发软件,然后选择File->New>New Project命令,即创建新项目。
    在这里插入图片描述
    点击图中的Next按钮,进入Maven多项目模块的命名界面,将坐标命名填写完整。
    在这里插入图片描述

    最后点击inish按钮。进入项目的初始化页面。
    在这里插入图片描述
    指定整个项目资源的编码及项目编译时采用的JDK版本。。配置信息如下:

    <!--定义项目整体资源编码及JDk 配置信息为1.8-->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>
        <maven.compiler.source>${java.version}</maven.compiler.source>
        <maven.compiler.target>${java.version}</maven.compiler.target>
    </properties>
    

    配置好以后,开始创建各个子模块及每个子模块最基本的一些依赖配置信息,首先是创建子模块api.
    在这里插入图片描述
    依次选择model选项,并填写名称,点击next,最终成功创建。
    在这里插入图片描述
    创建完成可以查看到父级POM文件多了 配置>api
    在这里插入图片描述

    然后我们在api模块的pom文件里加入整个项目都将使用的依赖配置,即Lombok和 Jackson解析依赖。注意:使用Lombok之前你使用的IDEA已经安装了Lombok插件。

    <properties>
        <lombok.version>1.16.6</lombok.version>
        <jackson-annotations-version>2.6.5</jackson-annotations-version>
    </properties>
    
    
    <dependencies>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
        </dependency>
    
    
        <!--jackson-->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>${jackson-annotations-version}</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>
    

    配置完成。再按照上面创建api子模块的方式,同样去创建子模块model。 点击项目,选择右键快捷菜单new命令,创建子模块model,并添加api子模块及spring-Mybatis依赖。具体操作如下:
    在这里插入图片描述
    然后子模块model依赖信息配置如下:

        <properties>
            <mybatis-spring-boot.version>1.1.1</mybatis-spring-boot.version>
            <mybatis-pagehelper.version>4.1.2</mybatis-pagehelper.version>
        </properties>
    
    
        <dependencies>
            <!--api-->
            <dependency>
                <groupId>com.debug.middleware</groupId>
                <artifactId>api</artifactId>
                <version>${project.parent.version}</version>
            </dependency>
    
    
            <!--spring-mybatis-->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis-spring-boot.version}</version>
            </dependency>
        </dependencies>
    

    按照同样的方式创建最后一个模块,即核心的server模块。可以说一个项目或者服务的大部分业务逻辑代码都将在这个模块中完成。最终新建完成的server模块如图所示:
    在这里插入图片描述
    其中在server模块中加入了相关的依赖包括spring Boot依赖,日志log4j,及mysql、druid等最基本的依赖配置。详细信息如下:

    <?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">
        <parent>
            <artifactId>middleware</artifactId>
            <groupId>com.debug.middleware</groupId>
            <version>1.0.1</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
    
        <artifactId>server</artifactId>
    
    
        <packaging>jar</packaging>
        <properties>
            <start-class>com.debug.middleware.server.MainApplication</start-class>
    
    
            <spring-boot.version>1.5.6.RELEASE</spring-boot.version>
            <spring-session.version>1.2.0.RELEASE</spring-session.version>
            <mysql.version>8.0.15</mysql.version>
            <druid.version>1.0.16</druid.version>
            <guava.version>19.0</guava.version>
        </properties>
    
    
        <!-- 依赖管理 -->
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-dependencies</artifactId>
                    <version>${spring-boot.version}</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>
    
    
    
    
        <dependencies>
            <!--日志-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-log4j</artifactId>
                <version>1.3.3.RELEASE</version>
            </dependency>
    
    
            <!--model-->
            <dependency>
                <groupId>com.debug.middleware</groupId>
                <artifactId>model</artifactId>
                <version>${project.parent.version}</version>
            </dependency>
    
    
            <!--guava-->
            <dependency>
                <groupId>com.google.guava</groupId>
                <artifactId>guava</artifactId>
                <version>${guava.version}</version>
            </dependency>
    
    
            <!--mysql-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
    
    
            <!--druid-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>${druid.version}</version>
            </dependency>
    
    
            <!--spring-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
                <version>${spring-boot.version}</version>
                <exclusions>
                    <exclusion>
                        <groupId>ch.qos.logback</groupId>
                        <artifactId>logback-classic</artifactId>
                    </exclusion>
                    <exclusion>
                        <groupId>org.slf4j</groupId>
                        <artifactId>log4j-over-slf4j</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
    
    
            <!-- redis -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-redis</artifactId>
                <version>1.3.3.RELEASE</version>
            </dependency>
    
    
    
    
    
    
    
    
            <!--for test-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <!--<scope>test</scope>-->
            </dependency>
        </dependencies>
    
    
        <build>
            <finalName>book_middleware_${project.parent.version}</finalName>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <version>${spring-boot.version}</version>
                    <executions>
                        <execution>
                            <goals>
                                <goal>repackage</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-war-plugin</artifactId>
                    <version>2.4</version>
                    <configuration>
                        <failOnMissingWebXml>false</failOnMissingWebXml>
                    </configuration>
                </plugin>
            </plugins>
    
    
            <resources>
                <resource>
                    <directory>src/main/resources</directory>
                    <filtering>true</filtering>
                </resource>
            </resources>
        </build>
    </project>
    

    至此,项目的各个模块已经初步搭建好了。其中,在server模块中指定了整个项目的启动类(也称应用接口)MainApplication。为了能使用Springboot内置容器将整个项目“跑”起来,需要对MainApplication进行改造。改造后的代码如下:

    package com.debug.middleware.server;
    
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    
    /**
    * @className: 启动类
    * @PackageName: com.debug.middleware.server
    * @author: youjp
    * @create: 2020-03-29 16:00
    * @description: TODO   启动类
    * @Version: 1.0
    */
    
    
    @SpringBootApplication
    public class MainApplication {
    
    
        public static void main(String[] args) {
            SpringApplication.run(MainApplication.class, args);
        }
    }
    

    其中注解@SpringootApplication 用于表示被注解的类为整个应用的入口启动类,到时候只需要单击该左边的运行按钮,即可将整个应用运行起来。

    为了将项目最终发步为完整的项目,我们为项目引入application.yml配置文件。

    spring:
      profiles:
        active: test
      application:
        name: middleware
      main:
        allow-bean-definition-overriding: true
      jackson:
        time-zone: GMT+8
        date-format: yyyy-MM-dd HH:mm:ss
      jmx:
        enabled: false
    
    
    server:
      port: 9031
    
    
    #logging\u65E5\u5FD7\u914D\u7F6E
    
    
    
    
    # mybatis 配置
    # mappers.xml文件配置
    mybatis:
      mapper-locations: classpath*:mybatis/mappers/**/**/*.xml
      # PO包路径配置
      type-aliases-package: com.deug.middleware
      # 驼峰命名转换xx_xx xxXx
      configuration:
        map-underscore-to-camel-case: true
    
    
    logging:
      path: ./logs/${spring.application.name}
      file: middleware
      level:
          org:
            springframework:  info
          com:
              fasterxml:
                  jackson:  info
              debug:
                  middleware: debug
    
    
    
    
    

    application-test.yml

    spring:
      # 数据库配置
      datasource:
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://127.0.0.1:3306/db_middleware?serverTimezone=GMT%2b8&characterEncoding=utf-8
        username: root
        password: 123456
    

    日志配置文件:log4j.properties ,放在resource文件下即可

    #Console Log
    log4j.rootLogger=INFO,console,debug,info,warn,error
    
    
    LOG_PATTERN=[%d{yyyy-MM-dd HH:mm:ss.SSS}] boot%X{context} - %5p [%t] --- %c{1}: %m%n
    
    
    #A1--Print log to Console
    log4j.appender.console=org.apache.log4j.ConsoleAppender
    log4j.appender.console.Threshold=DEBUG
    log4j.appender.console.layout=org.apache.log4j.PatternLayout
    log4j.appender.console.layout.ConversionPattern=${LOG_PATTERN}
    
    
    log4j.appender.info=org.apache.log4j.DailyRollingFileAppender
    log4j.appender.info.Threshold=INFO
    log4j.appender.info.File=${LOG_PATH}/${LOG_FILE}_info.log
    log4j.appender.info.DatePattern='.'yyyy-MM-dd
    log4j.appender.info.layout = org.apache.log4j.PatternLayout
    log4j.appender.info.layout.ConversionPattern=${LOG_PATTERN}
    
    
    log4j.appender.error=org.apache.log4j.DailyRollingFileAppender
    log4j.appender.error.Threshold=ERROR
    log4j.appender.error.File=${LOG_PATH}/${LOG_FILE}_error.log
    log4j.appender.error.DatePattern='.'yyyy-MM-dd
    log4j.appender.error.layout = org.apache.log4j.PatternLayout
    log4j.appender.error.layout.ConversionPattern=${LOG_PATTERN}
    
    
    
    
    log4j.appender.debug=org.apache.log4j.DailyRollingFileAppender
    log4j.appender.debug.Threshold=DEBUG
    log4j.appender.debug.File=${LOG_PATH}/${LOG_FILE}_debug.log
    log4j.appender.debug.DatePattern='.'yyyy-MM-dd
    log4j.appender.debug.layout = org.apache.log4j.PatternLayout
    log4j.appender.debug.layout.ConversionPattern=${LOG_PATTERN}
    
    
    log4j.appender.warn=org.apache.log4j.DailyRollingFileAppender
    log4j.appender.warn.Threshold=WARN
    log4j.appender.warn.File=${LOG_PATH}/${LOG_FILE}_warn.log
    log4j.appender.warn.DatePattern='.'yyyy-MM-dd
    log4j.appender.warn.layout = org.apache.log4j.PatternLayout
    log4j.appender.warn.layout.ConversionPattern=${LOG_PATTERN}
    

    最终server模块下resources目录的配置文件包含了3个文件。如图所示:
    在这里插入图片描述
    至此整个应用搭建 就完成了。

    写个hello World吧

    接下来写个hello word,用于检查上一节搭建的项目所发布的接口是否能被正常访问。

    1.在server模块下分别创建controller包和entity包。并在controller包下创建BookController 类,在entity包下创建Book类。

    BookController类开发的代码如下:

    package com.debug.middleware.server.controller;
    
    
    import com.debug.middleware.server.entity.Book;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import org.springframework.web.bind.annotation.RestController;
    
    
    /**
    * @className:
    * @PackageName: com.debug.middleware.server.controller
    * @author: youjp
    * @create: 2020-03-29 22:21
    * @description:    TODO 书籍控制器
    * @Version: 1.0
    */
    @RestController
    @RequestMapping("/book")
    public class BookController {
    
    
        private static final Logger log=LoggerFactory.getLogger(BookController.class);
    
    
        @RequestMapping(value = "info",method = RequestMethod.GET)
        public Book info(Integer no, String name){
            Book book=new Book();
            log.info("no:"+no+"name:"+name);
            book.setBookNo(no);
            book.setName(name);
            return book;
        }
    }
    

    Book类:

    package com.debug.middleware.server.entity;
    
    
    import lombok.Data;
    
    
    /**
    * @className:
    * @PackageName: com.debug.middleware.server.entity
    * @author: youjp
    * @create: 2020-03-29 22:19
    * @description: TODO
    * @Version: 1.0
    */
    @Data
    public class Book {
    
    
        /**
         * 书编号
         */
        private Integer bookNo;
    
    
        /**
         * 书名
         */
        private String name;
    
    
    }
    

    点击MainApplication启动项目。然后打开浏览器请求,地址栏输入

    http://localhost:9031/book/info?no=1&name=jp
    可查看结果:

    在这里插入图片描述

    源码地址:
    https://gitee.com/yjp245/middleware_study.git

    有兴趣的老爷,可以关注我的公众号【一起收破烂】,回复【006】获取2021最新java面试资料以及简历模型120套哦~
    在这里插入图片描述

    展开全文
  • 二、搭建微服务项目 创建maven父工程 创建服务提供方 创建服务调用方 一、在微服务中服务调用方式 1、RPC和HTTP 无论是微服务还是SOA,都面临着服务间的远程调用,那么服务间的远程调用...

    目录

     

    一、在微服务中服务调用方式

    1、RPC和HTTP

    2、Spring 的RestTemplate

    RestTemplate简单跨服务测试

     3、SpringCloud

    二、搭建微服务项目

    创建maven父工程

     创建服务提供方

    创建服务调用方 


    一、在微服务中服务调用方式

    1、RPC和HTTP

    无论是微服务还是SOA,都面临着服务间的远程调用,那么服务间的远程调用方式有哪些

    常见的远程调用方式有:

    RPC:Remote Produce Call远程过程调用,类似的还有RMI。自定义数据格式。基于原生TCP通信、速度快、效率高。早期的webservice,现在热门的dubbo,都是RPC的典型代表

    HTTP:http其实是一种网络传输协议,基于TCP,规定了数据传输的格式。现在客户端浏览器与服务端通信基本都是采用http协议,也可以用来进行远程服务调用。缺点是消息封装臃肿,优势是对服务的提供和调用方没有任何技术限定,自由灵活,更符合微服务理念。

    现在热门的rest风格,就可以通过http协议来实现。

     

    例如

    发送一个http请求(包含请求头和请求体)

    localhost:访问的是对应的ip地址主机

    8088:当访问到对应ip地址主机之后,进入到对应的进程端口

    /user/9:请求交给前端控制器DispatcherServlet处理,控制器通过HanderMapping找到相应的Controller组件处理请求,执行Controller组件约定方法处理请求,
    在约定方法调用模型组件完成业务处理。约定方法可以返回一个ModelAndView对象,封装了处理结果数据和视图名称信息,控制器接收ModelAndView之后,调用ViewResolver组件,
    定位View(JSP)并传递数据信息,生成响应页面

    2、Spring 的RestTemplate

    spring 提供了一个RestTemplate模板工具类,对基于http的客户端进行了封装,并且实现了对象与json的序列化和反序列化,非常方便。resttemplate并没有限定http的客户端类型,而是进行了抽象,目前常用的3种都有支持

    HttpClient

    OkHttp

    JDK原生的HttpUrlConnection(默认的)

    RestTemplate简单跨服务测试

    在没有指定RestTemplate的客户端类型,默认使用的是HttpUrlConnection

     拿到的是json数据,RestTemplate在底层将json转换成了对象

     运行

     3、SpringCloud

    微服务是一种结构方式,最终肯定需要技术架构去实现。

    微服务的实现方式很多,但是最火的莫过于spring cloud。

    后台硬:作为spring家族的一员,有整个spring全家桶靠山,背景十分强大。

    技术强:spring作为java领域的前辈,可以说是功力深厚。有强力的技术团队支撑,一般人还真比不起。

    群众基础好:可以说大多数程序员的成长都伴随着spring框架。

    使用方便:想想大家都体会到了springboot给我们开发带来的便利,而spring cloud完全支持springboot的开发,用很少的配置就能完成微服务框架的搭建

     

    二、搭建微服务项目

    在日常工作中我们采用的是创建独立的项目通过远程调用服务来实现各个服务之间的调用,现在我们为了方便起见,采用聚合工程的方式进行搭建。

    创建maven父工程

     需要子项目手动去引入

     创建服务提供方

    创建modul子项目user-service

     添加对应依赖

    配置文件

    创建springboot的启动类

    创建user类

    创建UserMapper接口

    创建UserService类

    创建userController类

     

    启动并访问

    现在服务的提供方就准备好了

    创建服务调用方 

    与上面类似,这里不再赘述,需要注意的是,我们调用user-service的功能,因此不需要mybatis相关依赖。

    创建modul子项目consumer-demo

    添加springboot的自动启动包

    创建springboot启动类,唯一不同之处在于使用了远程服务调用RestTemplate

    创建user类

    创建ConsumerController来实现远程数据库查询的服务调用

    这个时候刷新一下整个maven项目

    点击右下角出现的弹框

     以后就可以直接在这里启动

    展开全文
  • idea搭建微服务项目

    千次阅读 2020-07-20 17:33:35
    简单的项目构建 1、首先,再idea创建项目,create project,然后next 2、项目名随便,然后next 3、勾上下面着几个,可按照自己的需求勾选,然后next,完成 4、等jar下好 5、建议把配置文件扩展名改为yml,并...

    简单的项目构建

    1、首先,在idea创建项目,create project,然后next
    在这里插入图片描述
    2、项目名随便,然后next
    在这里插入图片描述
    3、勾上下面这几个,可按照自己的需求勾选,然后next,完成
    在这里插入图片描述
    在这里插入图片描述
    4、等jar下好
    在这里插入图片描述
    5、建议把配置文件扩展名改为yml,并加上以下配置(注意空格)
    在这里插入图片描述

    server:
    port: 8888

    eureka:
    instance:
    hostname: localhost
    client:
    registerWithEureka: false
    fetchRegistry: false
    serviceUrl:
    defaultZone: http://eureka.instance.hostname:{eureka.instance.hostname}:{server.port}/eureka/
    6、再给启动函数配置
    在这里插入图片描述
    7、然后启动,打开网页,输入配置的地址和端口,出现这个页面,成功
    在这里插入图片描述

    展开全文
  • 一 新建一个项目作为微服务项目的父项目 基于此,该项目什么组件都不选,整个项目由maven进行管理,因为微服务需要一个父模块+多个子模块,我们就将该项目作为父模块并利用它来管理子模块。 二 新建一个子...
  • 初学者微服务项目搭建详细教程 微服务常用的常用组件 服务治理: Spring Cloud Eureka 客户端负载均衡: Spring Cloud Ribbon 服务容错保护: Spring Cloud Hystrix 声明式服务调用: Spring Cloud Feign API 网关...
  • 今天来教大家如何快速搭建一个微服务项目,其实很简单,首先使用编辑器新建一个maven项目,然后在pom.xml中添加相关的依赖包就好。我接下来用idea来搭建一个微服务项目,如图。 1、新建maven项目。这个操作很简单,...
  • 搭建微服务项目架子 新建项目 启动项目 直接启动 找到配置文件 通过yml配置 架子结束 新建项目 直接用idea新建,或者到 spring 这里使用idea 设置组名称和项目名 目前只会java语言 打包war包方便部署...
  • 福兮祸所伏,祸兮福所倚 今天初步了解了微服务 所以记录下 首先咱们来了解下什么是微服务架构和微服务 ...理解了这两个概念之后 咱们就开始咱们的搭建工作(这里我使用的idea来创建的) : ...
  • 搭建微服务项目时,使用springCloud中的sleush进行服务的链路追踪,使用到zipkin进行查看链路时,无法显示链路问题 在搭建微服务项目时,使用springCloud中的sleush进行服务的链路追踪,使用到zipkin进行查看链路...
  •  本文为使用 Spring Cloud 搭建微服务项目架构的整体思路讲述,欢迎讨论。文章对新手不友好,推荐新手访问此文: 史上最简单的 SpringCloud 教程 | 终章 ,讲得很好。 1、微服务的定义  微服务的通俗定义...
  • springCloud认识微服务认识springCloudSpringCloud Eureka 服务发现框架SpringCloud Ribbon 负载均衡SpringCloud Hystrix 容错保护SpringCLoud Zull 服务网关 认识微服务 什么是微服务 将一个独立的系统拆分成若干...
  • 1.搭建整体父工程 microservicecloud 新建父工程microservicecloud,切记是Packageing是pom模式 主要是定义POM文件,将后续各个子模块公用的jar包等统一提出来,类似一个抽象父类 1.pom.xml <project xmlns...
  • 1.创建Maven项目 2.删除src文件夹
  • 一、创建普通maven项目,该项目微服务架构中的父项目项目:springcloud pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi=...
  • 微服务是什么? 微服务是一种架构思想,重点在于将服务颗粒化,分而治之。 各个服务之间通过restful API之类的轻量级通讯机制来进行交互。 微服务遵循的原则是什么? 1.高内聚,低耦合:根据业务建模,把每个功能...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,409
精华内容 1,763
关键字:

搭建微服务项目