spring cloud eureka 服务提供者

1.pom.xml

<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/maven-v4_0_0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <groupId>mis-api</groupId>
   <artifactId>mis-api</artifactId>
   <packaging>jar</packaging>
   <version>0.0.1-SNAPSHOT</version>
   <name>mis-api Maven Webapp</name>
   <url>http://maven.apache.org</url>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.0.4.RELEASE</version>
      <relativePath/>
   </parent>
   <properties>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
         <!--<exclusions>
            <exclusion>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-tomcat</artifactId>
            </exclusion>
         </exclusions>-->
      </dependency>
      <!--<dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-tomcat</artifactId>
         <scope>provided</scope>
      </dependency>-->
      <dependency>
         <groupId>org.mybatis.spring.boot</groupId>
         <artifactId>mybatis-spring-boot-starter</artifactId>
         <version>1.3.2</version>
      </dependency>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
      </dependency>
      <!-- mysql driver -->
      <dependency>
         <groupId>mysql</groupId>
         <artifactId>mysql-connector-java</artifactId>
      </dependency>
      <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <scope>test</scope>
      </dependency>
      <!--添加servlet-api的依赖 -->
      <dependency>
         <groupId>javax.servlet</groupId>
         <artifactId>javax.servlet-api</artifactId>
         <scope>provided</scope>
      </dependency>
      <!-- 引入swagger包 -->
      <dependency>
         <groupId>io.springfox</groupId>
         <artifactId>springfox-swagger2</artifactId>
         <version>2.4.0</version>
      </dependency>
      <dependency>
         <groupId>io.springfox</groupId>
         <artifactId>springfox-swagger-ui</artifactId>
         <version>2.4.0</version>
      </dependency>
      <dependency>
         <groupId>net.sf.json-lib</groupId>
         <artifactId>json-lib</artifactId>
         <version>2.2.3</version>
         <classifier>jdk15</classifier>
      </dependency>
   </dependencies>
   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Finchley.RELEASE</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>
         <plugin>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-maven-plugin</artifactId>
            <version>1.3.5</version>
            <executions>
               <execution>
                  <id>Generate MyBatis Artifacts</id>
                  <goals>
                     <goal>generate</goal>
                  </goals>
                  <phase>deploy</phase>
               </execution>
            </executions>
            <configuration>
               <configurationFile>src/main/resources/rest/pmis/pmis-mybatis-config.xml</configurationFile>
               <overwrite>false</overwrite>
            </configuration>
         </plugin>
      </plugins>
      <resources>
         <resource>
            <directory>src/main/resources</directory>
            <includes>
               <include>**/*.xml</include>
               <include>**/*.properties</include>
            </includes>
         </resource>
      </resources>
      <finalName>mis-api</finalName>
   </build>


</project>

2.application.properties

server.port=8080

spring.application.name=mis-api-service
eureka.client.serviceUrl.defaultZone=http://localhost:1111/eureka

#### 数据库连接池属性
#Spring Boot 2.0 includes HikariDataSource by default
#spring.datasource.type = com.zaxxer.hikari.HikariDataSource
spring.datasource.hikari.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.hikari.jdbc-url=jdbc:mysql://ip:3306/database?useUnicode=true&characterEncoding=utf8
spring.datasource.hikari.username=root
spring.datasource.hikari.password=
spring.datasource.hikari.connection-timeout=20000
spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.maximum-pool-size=300
spring.datasource.hikari.idle-timeout=300000
spring.datasource.hikari.max-lifetime=1200000
spring.datasource.hikari.auto-commit=true
#扫描pojo类的位置,在此处指明扫描实体类的包，在mapper中就可以不用写pojo类的全路径名了
spring.mybatis.pmis.type-aliases-package=rest.pmis.dao
#mybatis mapper文件的位置
spring.mybatis.pmis=classpath:rest/pmis/mapper/*.xml
pmis.api.useKey=
logging.level.root=INFO

3.configurations class

数据库配置

package rest.config;

import java.io.IOException;

import javax.sql.DataSource;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.env.Environment;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

@Configuration
@MapperScan(basePackages={"rest.pmis.dao"},sqlSessionFactoryRef="pmisSqlSessionFactory")
public class HikariCPDatasourceConfig {
   @Autowired
   private Environment env;
   @Bean(name="pmisDataSource")
   @ConfigurationProperties(prefix="spring.datasource.hikari")
   public DataSource pmisDataSource(){
      return DataSourceBuilder.create().build();
//    return DataSourceBuilder.create(HikariCPDatasourceConfig.class.getClassLoader())
//          .type(HikariCPDatasourceConfig.class)
//          .driverClassName(properties.determineDriverClassName())
//          .url(properties.determineUrl())
//          .username(properties.determineUsername())
//          .password(properties.determinePassword())
//          .build();

   }
   @Bean(name="pmisSqlSessionFactory")
   public SqlSessionFactory createPmisSqlSessionFactory(){
      SqlSessionFactoryBean sf=new SqlSessionFactoryBean();
      sf.setDataSource(pmisDataSource());
      sf.setTypeAliasesPackage(env.getProperty("spring.mybatis.pmis.type-aliases-package"));
      try {
         sf.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(env.getProperty("spring.mybatis.pmis")));
      } catch (IOException e) {
         e.printStackTrace();
      }
      try {
         return sf.getObject();
      } catch (Exception e) {
         e.printStackTrace();
      }
      return null;
   }
   @Bean
   public SqlSessionTemplate sqlSessionTemplate1() throws Exception {
   SqlSessionTemplate template = new SqlSessionTemplate(createPmisSqlSessionFactory());
   return template;
   }
   @Bean(name="pmisTransactionManager")
   @Primary
   public DataSourceTransactionManager dyk3TransactionManager(){
      return new DataSourceTransactionManager(pmisDataSource());
   }
}

swagger 配置

package rest.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class SwaggerConfig {
    @Bean
    public Docket api(){
        return new Docket(DocumentationType.SWAGGER_2)
                .groupName("pmis apis 2019")
                .apiInfo(getApiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("rest.pmis.services"))
                .paths(PathSelectors.any())
                .build()
                ;
    }

    private ApiInfo getApiInfo(){
        return new ApiInfoBuilder()
                .title("PMIS接口")
                .description("设备清单接口")
                .contact(new Contact("huangjuan","",""))
                .version("1.0")
                .license("Apache 2.0")
                .licenseUrl("http://www.apache.org/licenses/LICENSE-2.0")
                .build();
    }
}

swagger页面配置

package rest.config;

import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        // 解决 SWAGGER 404报错
        registry.addResourceHandler("/**/swagger-ui.html").addResourceLocations("classpath:/META-INF/resources/");
        registry.addResourceHandler("/**/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
        registry.addResourceHandler("/**/swagger-resources/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
    }
}

environment配置

package rest.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;

@Component
@PropertySource("classpath:application.properties")
public class PropertiesConfig {
   @Autowired
    private Environment env;

   public Environment getEnv() {
      return env;
   }

   public void setEnv(Environment env) {
      this.env = env;
   }
   
}

3.pmis api

package rest.pmis.services;

import io.swagger.annotations.ApiParam;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import rest.pmis.dao.OrderItemGroupMapper;
import rest.pmis.dao.OrderItemMapper;
import rest.pmis.dao.OrderMapper;
import rest.pmis.model.OrderItemGroup;
import rest.pmis.model.OrderItemWithBLOBs;
import rest.pmis.model.OrderWithBLOBs;
import rest.util.JudgeUseKey;

import java.util.List;

@RestController
public class PmisApi {
   @Autowired
   private OrderItemMapper orderItemMapper;
   @Autowired
   private OrderMapper orderMapper;
   @Autowired
   private OrderItemGroupMapper orderItemGroupMapper;
   @Autowired
   private JudgeUseKey judgeUseKey;
   @RequestMapping(value="/hello")
   public String testHello(){
      return "hello world";
   }
   @RequestMapping(method=RequestMethod.POST,value="/searchOrderItemById")
   public String searchOrderItemById(@RequestParam("id") Integer id,@RequestParam("useKey") String useKey){
      if(judgeUseKey.rightUseKey(useKey)){
         OrderItemWithBLOBs orderItemWithBlobs= orderItemMapper.selectByPrimaryKey(id);
         JSONObject jsonObject= JSONObject.fromObject(orderItemWithBlobs);
         return jsonObject.toString();
      }else{
         return "";
      }
   }
   @RequestMapping(method = RequestMethod.POST,value = "/searchOrderListByProjectNo")
   public String searchOrderListByProjectNo(@RequestParam("orderCode") String orderCode,@RequestParam("useKey") String useKey){
      if (judgeUseKey.rightUseKey(useKey)){
         List<OrderWithBLOBs> orderWithBLOBs=orderMapper.selectOrderListByOrderCode(orderCode);
         JSONArray jsonObjectArray=JSONArray.fromObject(orderWithBLOBs);
         return jsonObjectArray.toString();
      }else{
         return "";
      }
   }
   @RequestMapping(method = RequestMethod.POST,value = "/selectOrderItemGroupByConditions")
   public String selectOrderItemGroupByConditions(@RequestBody @ApiParam(name = "OrderItemGroup",required = true) OrderItemGroup orderItemGroup, @ApiParam(name="useKey",value="接口密钥",required = true) @RequestParam("useKey") String useKey){
      if (judgeUseKey.rightUseKey(useKey)){
         List<OrderItemGroup> list=orderItemGroupMapper.selectOrderItemGroupByConditions(orderItemGroup);
         JSONArray jsonArray=JSONArray.fromObject(list);
         return  jsonArray.toString();
      }else {
         return "";
      }
   }
   @RequestMapping(method = RequestMethod.POST,value = "/selectOrderItemListByConditions")
   public String selectOrderItemListByConditions(@RequestBody @ApiParam(name = "OrderItem",required = true) OrderItemWithBLOBs orderItemWithBLOBs,@RequestParam("useKey") String useKey){
      if (judgeUseKey.rightUseKey(useKey)){
         List<OrderItemWithBLOBs> list=orderItemMapper.selectOrderItemListByConditions(orderItemWithBLOBs);
         JSONArray jsonArray=JSONArray.fromObject(list);
         return jsonArray.toString();
      }else {
         return "";
      }
   }
}

4.启动类

package rest;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient
public class MisApiApplication
//    extends SpringBootServletInitializer
{
   public static void main(String[] args) {
      SpringApplication.run(MisApiApplication.class, args);
   }
// @Override
// protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
//    return builder.sources(MisApiApplication.class);
// }
}