基于Spring Boot的微服务搭建

环境：

项目结构：

关键配置

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.xlc</groupId>
    <artifactId>demohmm</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

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

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.6.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>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</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>

application.yml

spring:
  datasource:
     driver-class-name: com.mysql.jdbc.Driver
     url: jdbc:mysql:///parameter?useSSL=false
     username: root
     password: 123456
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

Table1.java

package com.xlc.hmm;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;

import org.hibernate.annotations.Proxy;

@Entity
@Proxy(lazy = false)
public class Table1 {

    @Id
    @Column(name="id")
    private int id;
    @Column(name="wordlist")
    private String wordList;
    @Column(name="labellist")
    private String labelList;
    @Column(name="wordsize")
    private int wordSize;
    @Column(name="labelsize")
    private int labelSize;
    @Column(name="pi")
    private String pi;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getWordList() {
        return wordList;
    }
    public void setWordList(String wordList) {
        this.wordList = wordList;
    }
    public String getLabelList() {
        return labelList;
    }
    public void setLabelList(String labelList) {
        this.labelList = labelList;
    }
    public int getWordSize() {
        return wordSize;
    }
    public void setWordSize(int wordSize) {
        this.wordSize = wordSize;
    }
    public int getLabelSize() {
        return labelSize;
    }
    public void setLabelSize(int labelSize) {
        this.labelSize = labelSize;
    }
    public String getPi() {
        return pi;
    }
    public void setPi(String pi) {
        this.pi = pi;
    }
    @Override
    public String toString() {
        return "Table1 [id=" + id + ", wordList=" + wordList + ", labelList=" + labelList + ", wordSize=" + wordSize
                + ", labelSize=" + labelSize + ", pi=" + pi + "]";
    }

}

Table2、Table3同理基于数据库映射关系构建

Table1Respository.java

package com.xlc.hmm;

import org.springframework.data.jpa.repository.JpaRepository;
                                                                 //此处可以指定其他类型，因需而定
public interface Table1Respository extends JpaRepository<Table1, Integer>{}

Table2Respository.java、Table2Respository.java同理

HmmController.java

package com.xlc.hmm;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import javax.annotation.PostConstruct;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

//@Component
//@Order(value=1)
//class StartUpRunner implements CommandLineRunner {
//    @Override
//    public void run(String... args) throws Exception {
////        new ParamFromSql();
//        System.out.println("SUCCESS");
//    }
//}

@Component
class ParamFromSql {

    @Autowired
    private Table1Respository table1Respository;

    @Autowired
    private Table2Respository table2Respository;

    @Autowired
    private Table3Respository table3Respository;

    public static ParamFromSql paramFromSql;

    static List<String> wordlist;
    static List<String> labellist;
    static double[] pi;
    static double[][] A;
    static double[][] B;

    @PostConstruct
    public void init() {

        paramFromSql = this;
        paramFromSql.table1Respository = this.table1Respository;
        paramFromSql.table2Respository = this.table2Respository;
        paramFromSql.table3Respository = this.table3Respository;

        wordlist = new ArrayList<String>();
        labellist = new ArrayList<String>();
//        getParamFromMysql();
//        Table1 table1 = paramFromSql.table1Respository.getOne(1);
//        paramFromSql.table1Respository.getOne(1);
//        System.out.println(paramFromSql.table1Respository.getOne(1));
        Table1 table1 = paramFromSql.table1Respository.getOne(1);
        System.out.println(table1.getLabelList());
        labellist = Arrays.asList(table1.getLabelList().split(" "));
        wordlist = Arrays.asList(table1.getWordList().split(" "));
        String[] piStr = table1.getPi().split(" ");
        int labelSize= table1.getLabelSize();
        int wordSize = table1.getWordSize();
        pi = new double[labelSize];
        A = new double[labelSize][labelSize];
        B = new double[labelSize][wordSize];

        int j = 1;
        for (int i = 0; i < labelSize; ++i) {
            pi[i] = Double.valueOf(piStr[i]);

            String[] rowAStrs = paramFromSql.table2Respository.getOne(j).getRowA().split(" ");
            for(int k = 0; k < labelSize; ++k) {
                A[i][k] = Double.valueOf(rowAStrs[k]);
            }

            String[] rowBStrs = paramFromSql.table3Respository.getOne(j).getRowB().split(" ");
            for(int k = 0; k < wordSize; ++k) {
                B[i][k] = Double.valueOf(rowBStrs[k]);
            }

            ++j;

        }

        System.out.println("SUCCESS");
    }

}

class Test{
    public void test() {
        System.out.println("-------------------------");
        System.out.println(ParamFromSql.A[0][0]);
        System.out.println(ParamFromSql.B[0][0]);
        System.out.println("-------------------------");
    }
}

class SetLabel{

    public String setLabel(String strInput) {
        String result = "";
        try {
            int[] labelindex = viterbi(strInput, ParamFromSql.pi, ParamFromSql.A, ParamFromSql.B);
            String[] strwords = strInput.split(" ");
            for (int i = 0; i < labelindex.length; i++) {
                result += strwords[i] + "/" + ParamFromSql.labellist.get(labelindex[i]) + " ";

            }
        }catch(Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    // viterbi
    public int[] viterbi(String string, double[] pi, double[][] A, double[][] B) throws IOException{

        String[] words = string.split(" ");
        double[][] delta = new double[words.length][pi.length];
        int[][] way = new int[words.length][pi.length];
        int[] labelindex = new int[words.length];
        //System.out.println(words[0]);
        for (int i = 0; i < pi.length; i++) {
            delta[0][i] = pi[i] * B[i][ParamFromSql.wordlist.indexOf(words[0])];  //////////////////////////////////////////////
        }
        for (int t = 1; t < words.length; t++) {
            //System.out.println(words[t]);
            for (int i = 0; i < pi.length; i++) {
                for (int j = 0; j < pi.length; j++) {
                    ////////
                    //System.out.println("t:" +t + "i:" + i + "j:" + j + "wordlist.indexOf(words[t]):"
                        //    + wordlist.indexOf(words[t]));
                    if(delta[t][i] < delta[t-1][j] * A[j][i] * B[i][ParamFromSql.wordlist.indexOf(words[t])]) {
                        delta[t][i] = delta[t-1][j] * A[j][i] * B[i][ParamFromSql.wordlist.indexOf(words[t])];
                        way[t][i] = j;
                    }
                }
            }
        }
        double max = delta[words.length - 1][0];
        labelindex[words.length - 1] = 0;
        for (int i = 0; i < pi.length; i++) {
            if (delta[words.length - 1][i] > max) {
                max = delta[words.length - 1][i];
                labelindex[words.length - 1] = i;
            }
        }
        for (int t = words.length - 2; t >= 0; t--) {
            labelindex[t] = way[t + 1][labelindex[t + 1]];
        }
        //System.out.println(Arrays.toString(labelindex));
        return labelindex;
    }

}

@RestController
public class HmmController {

    public String justDoIt(String str) {
        String resultStr = null;
        try {
            resultStr =  new SetLabel().setLabel(str);
        }catch(Exception e) {
            e.printStackTrace();
        }

        return resultStr;
    }

    @PostMapping("/hmm")
    public String hmmDemo(@RequestParam(value = "str", required = false, defaultValue = "0") String testStr) {//        return testStr;
        if(testStr.equals("0")) {
            return "are you kidding me?";
        }else {
            return justDoIt(testStr);
        }

    }

    @GetMapping("/test")
    public String test() {
//        new Test().test();
        return "do you like me?";
    }

}

DemohmmApplication.java

package com.xlc;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemohmmApplication {

    public static void main(String... args) {

        SpringApplication.run(DemohmmApplication.class, args);
    }
}

现在右键DemohmmApplication运行，启动项目

看见这个是不是很激动

  .   ____          _            __ _ _
 /\\ / ___‘_ __ _ _(_)_ __  __ _ \ \ \ ( ( )\___ | ‘_ | ‘_| | ‘_ \/ _` | \ \ \  \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  ‘  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v2.0.6.RELEASE)

现在来使用Postman测试一下

简单Get请求

微服务测试（通过Post请求传入参数）

其实整个项目结构还是很清晰的

对于很多注解的使用，就需要好好的看书或着通过其他途径来学习一下了

这里再详细说明一下遇到的一个问题：在启动服务的时候将必要的模型参数读入内存以便在服务使用时可以很快的给出结果，而不是每请求一次就去数据库中读取一次参数，这样是耗时且不明智的

于是就使用到了@Component，被注解的类在项目启动时会进行加载，在这个类中可以定义

@Autowired
private Table1Respository table1Respository;

而不会在后续读库时报空指针异常

具体的用法就是

@Component
class ParamFromSql {

    @Autowired
    private Table1Respository table1Respository;

    public static ParamFromSql paramFromSql;

    @PostConstruct
    public void init() {

        paramFromSql = this;
        paramFromSql.table1Respository = this.table1Respository;
    }
}

想要获取操作数据库就使用 paramFromSql.table1Respository.具体的方法

还有一个重要的问题就是Hibernate默认的Lazy模式导致的no session异常

此时一个简单粗暴的解决办法就是在实体类上加注解指明不适用Lazy

如

@Entity
@Proxy(lazy = false)
public class Table1 {}

Github：https://github.com/xinglicha0/SpringBoot-Hmm

原文地址：https://www.cnblogs.com/xinglichao/p/9953224.html

时间： 2024-08-28 22:04:18

基于Spring Boot的微服务搭建的相关文章

基于Spring Cloud的微服务构建学习-2 Spring Boot

基于Spring Cloud的微服务构建学习-2 Spring Boot 为什么使用Spring Boot而不是Spring Spring Boot具有自动化配置,快速开发,轻松部署优点,非常适合用作微服务架构中各项具体微服务的开发框架.它不仅可以帮助我们快速的构建微服务,还可以轻松简单的整合Spring Cloud实现系统服务化,而如果使用了传统的Spring构建方式的话,在整合过程中我们还需要做更多的依赖管理工作才能让它们完好的运行起来. Spring Boot的宗旨并非是重写Spring或

Spring Boot 实践3 --基于spring cloud 实现微服务的简单调用

背景:spring boot主张微服务,所以这里不得不提出服务之间的调用这次我们使用srping cloud作为服务集成与管理者 (转载请注明来源:cnblogs coder-fang) 根据实践1,创建一个spring boot 项目(springServer),作为服务中心: springServer的pom文件如下: <?xml version="1.0" encoding="UTF-8"?> <project xmlns="h

基于Spring Cloud的微服务构建学习-3 服务治理：Spring Cloud Eureka

基于Spring Cloud的微服务构建学习-3 服务治理:Spring Cloud Eureka 什么是服务治理服务治理可以说是微服务架构中最为核心和基础的模块,它主要用来实现各个微服务实例的自动化注册与发现. 为什么需要服务治理模块在最初构建微服务系统的时候可能服务并不多,我们可以通过做一些静态配置来完成服务调用此时看着一切都还正常. 随着项目逐渐接近尾声,维护人员需要维护的服务越来越多,越来越复杂,最终形成大量的配置文件,维护将会变得越来越困难.此时,微服务应用实例自动化管理框架变得

基于Spring Cloud的微服务落地

请点击此处输入图片描述微服务架构模式的核心在于如何识别服务的边界,设计出合理的微服务.但如果要将微服务架构运用到生产项目上,并且能够发挥该架构模式的重要作用,则需要微服务框架的支持. 在Java生态圈,目前使用较多的微服务框架就是集成了包括Netfilix OSS以及Spring的Spring Cloud.它包括: Spring Cloud Config:配置管理工具,支持使用Git存储配置内容,可以实现应用配置的外部化存储,支持客户端配置信息刷新.加密/解密配置内容等. Spring Clo

Spring Boot、微服务架构和大数据

一文读懂 Spring Boot.微服务架构和大数据治理三者之间的故事 https://www.cnblogs.com/ityouknow/p/9034377.html 微服务架构微服务的诞生并非偶然,它是在互联网高速发展,技术日新月异的变化以及传统架构无法适应快速变化等多重因素的推动下诞生的产物.互联网时代的产品通常有两类特点:需求变化快和用户群体庞大,在这种情况下,如何从系统架构的角度出发,构建灵活.易扩展的系统,快速应对需求的变化:同时,随着用户的增加,如何保证系统的可伸缩性.高可用性,

一文读懂 Spring Boot、微服务架构和大数据治理三者之间的故事

微服务的诞生并非偶然,它是在互联网高速发展,技术日新月异的变化以及传统架构无法适应快速变化等多重因素的推动下诞生的产物. 微服务的诞生并非偶然,它是在互联网高速发展,技术日新月异的变化以及传统架构无法适应快速变化等多重因素的推动下诞生的产物.互联网时代的产品通常有两类特点:需求变化快和用户群体庞大,在这种情况下,如何从系统架构的角度出发,构建灵活.易扩展的系统,快速应对需求的变化:同时,随着用户的增加,如何保证系统的可伸缩性.高可用性,成为系统架构面临的挑战.如果你想了解大数据的学习路线,想学习

使用Spring Boot构建微服务（文末福利）

本文主要内容学习微服务的关键特征了解微服务是如何适应云架构的将业务领域分解成一组微服务使用Spring Boot实现简单的微服务掌握基于微服务架构构建应用程序的视角学习什么时候不应该使用微服务软件开发的历史充斥着大型开发项目崩溃的故事,这些项目可能投资了数百万美元.集中了行业里众多的顶尖人才.消耗了开发人员成千上万的工时,但从未给客户交付任何有价值的东西,最终由于其复杂性和负担而轰然倒塌. 这些庞大的项目倾向于遵循大型传统的瀑布开发方法,坚持在项目开始时界定应用的所有需求和设计.这

代码大爆炸|用Spring Boot创建微服务的21种代码描述（上）

代码大爆炸|用Spring Boot创建微服务的21种代码描述(上)

使用Spring Boot创建微服务

过去几年以来,"微服务架构"的概念已经在软件开发领域获得了一个稳定的基础.作为"面向服务架构"(SOA)的一个继任者,微服务同样也可以被归类为"分布式系统"这一类,并且进一步发扬了SOA中的许多概念与实践.不过,它们在不同之处在于每个单一服务所应承担的责任范围.在SOA中,每个服务将负责处理广范围的功能与数据领域,而微服务的一种通用指南则认为,它所负责的部分是管理一个单独的数据领域,以及围绕着该领域的相关功能.使用分布式系统方式的目的是将整体性的