婉哥

SpringCloud+Netflix（Eureka+Ribbon+Hystix）入门教程+demo（一）

1.系统架构演变

1.1集中式架构

当网站流量小时，只需一个应用，将所有功能部署在一块。

问题：

代码耦合度高，开发维护困难。
无法针对不同模块进行针对性优化。
无法水平扩展。
单点容错率低，并发能力差。

1.2垂直拆分

按照功能区划分，把不同的功能模块独立出来。

优点：

系统拆分实现了流量分担，解决了并发问题。
可以针对不同模块进行优化。
方便水平扩展，负载均衡，容错率提高

缺点：

系统间相互独立，会有很多重复开发工作，影响开发效率

1.3分布式服务

服务间的调用，服务间首先相互独立，其次相互调用。

当垂直应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。此时，用于提高业务复用及整合的分布式调用是关键。

优点：

将基础服务进行了抽取，系统间相互调用，提高了代码复用和开发效率。

缺点：

系统间耦合度变高，调用关系错综复杂，难以维护。

1.4流动计算架构（SOA）

SOA：面向服务的架构
当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加一个调度中心基于访问压力实时管理集群容量，提高集群利用率。此时，用于提高机器利用率的资源调度和治理中心(SOA)是关键。

服务治理要做什么？

服务注册中心，实现服务自动注册和发现，无需人为记录服务地址
服务自动订阅，服务列表自动推送，服务调用透明化，无需关心依赖关系
动态监控服务状态监控报告，人为控制服务状态

缺点：

服务间会有依赖关系，一旦某个环节出错会影响较大。
服务关系复杂，运维、测试部署困难，不符合DevOps思想。

1.5微服务

微服务的特点：

单一职责：微服务中每一个服务都对应唯一的业务能力，做到单一职责。
微：微服务的服务拆分粒度很小，例如一个用户管理就可以作为一个服务。每个服务虽小，但“五脏俱全”。
面向服务：面向服务是说每个服务都要对外暴露服务接口API。并不关心服务的技术实现，做到与平台和语言无关，也不限定用什么技术实现，只要提供Rest的接口即可。
自治：自治是说服务间互相独立，互不干扰。
团队独立：每个服务都是一个独立的开发团队，人数不能过多。
技术独立：因为是面向服务，提供Rest接口，使用什么技术没有别人干涉。
前后端分离：采用前后端分离开发，提供统一Rest接口，后端不用再为PC、移动段开发不同接口。
数据库分离：每个服务都使用自己的数据源。
部署独立，服务间虽然有调用，但要做到服务重启不影响其它服务。有利于持续集成和持续交付。每个服务都是独立的组件，可复用，可替换，降低耦合，易维护。

2.服务调用方式

2.1RPC和HTTP

RPC：远程过程调用，类似还有RMI（远程方法调用）。基于原生TCP通信。典型代表框架：dubbo、webservice。
HTTP：基于TCP，规定了数据传输的格式。缺点是消息封装囊肿，优点是灵活。
现在热门的Rest风格，就可以通过http协议来实现。

如果公司都采用java技术性，那么使用dubbo作为服务架构是不错的。
如果技术栈多样化，那么SpringCloud搭建微服务是不二之选。

2.2Http客户端工具

java代码间调用，主流客户端：

HttpClient（Apache的）
OKHttp
HttpUrlConnection
不同客户端，API各不相同。

2.3Spring的RestTemplate

Spring提供了一个RestTemplate模板工具类，对于Http的客户端进行了封装，并实现了对象与json的序列化和反序列化。
RestTemplate并没有限定Http的客户端类型，而是进行了抽象。目前常用的3中都有支持：

HttpClient
OKHttp
JDK原生的HttpUrlConnection（默认的）

2.3Spring的RestTemplate

２.3.1新导入demo工程

2.3.2编写测试类

先在项目中注册一个RestTemplate对象，可以在启动类位置注册：

package com.leyou.httpdemo;

import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class HttpDemoApplication {

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

	@Bean
	public RestTemplate restTemplate() {
		//默认的HtppUrlConnection，将Template注册到Spring
		return new RestTemplate();
	}
}

在测试类中直接注入

package com.leyou.httpdemo;

import com.leyou.httpdemo.pojo.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.web.client.RestTemplate;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = HttpDemoApplication.class)
public class HttpDemoApplicationTests {

	@Autowired
	private RestTemplate restTemplate;

	@Test
	public void httpGet() {
		User user = this.restTemplate.getForObject("http://localhost:8088/user/16", User.class);
		System.out.println(user);
	}

}

通过RestTemplate的getForObject（）方法，传递url地址及实体类的字节码，RestTemplate会自动发起请求，接受相应，并且帮我们对相应结果进行反序列化。
注意：这个项目和要引用的项目接口要保证tomcat端口不同，否则会报错端口被占用。

3.初始SpringCloud

3.1简介

Spring最擅长的就是集成，把世界上最好的框架拿过来，集成到自己的项目中，
SpringCloud也是一样，它将现在非常流行的一些技术整合到一起，实现了诸如：配置管理，服务发现，智能路由，负载均衡，熔断器，控制总线，集群状态等等功能。其主要涉及的组件包括：

Netflix

Eureka：注册中心
Zuul：服务网关
Ribbon：负载均衡
Feign：服务调用
Hystix：熔断器

架构图：

4.微服务场景模拟

4.1创建父工程

4.1.1创建一个maven工程cloud-demo

4.1.2引入依赖

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.4.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.SR1</spring-cloud.version>
        <mapper.starter.version>2.0.3</mapper.starter.version>
        <mysql.version>5.1.32</mysql.version>
        <pageHelper.starter.version>1.2.5</pageHelper.starter.version>
    </properties>
    <!-- dependency管理器中所有子工程都有该依赖-->
<dependencyManagement>
    <dependencies>
        <!--springcloud版本依赖项目-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <!--通用mapper启动器 -->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>${mapper.starter.version}</version>
        </dependency>
        <!-- mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
    </dependencies>
</dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

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

4.2服务提供者

4.2.1新建一个子工程（Module）

假设该工程对外提供查询用户的服务。

4.2.2引入依赖

    <parent>
        <artifactId>cloud-demo</artifactId>
        <groupId>cn.itcast.demo</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>user-service</artifactId>

    <dependencies>
        <!-- Spring工程的web启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
        </dependency>
    </dependencies>

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>cn.itcast</groupId>
    <artifactId>cloud-demo</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>user-service</module>
    </modules>


    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.4.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.SR1</spring-cloud.version>
        <mapper.starter.version>2.0.3</mapper.starter.version>
        <mysql.version>5.1.32</mysql.version>
        <pageHelper.starter.version>1.2.5</pageHelper.starter.version>
    </properties>
    <!-- dependency管理器中所有子工程都有该依赖-->
    <dependencyManagement>
        <dependencies>
            <!--springcloud版本依赖项目-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--通用mapper启动器 -->
            <dependency>
                <groupId>tk.mybatis</groupId>
                <artifactId>mapper-spring-boot-starter</artifactId>
                <version>${mapper.starter.version}</version>
            </dependency>
            <!-- mysql驱动-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

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

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">
    <parent>
        <artifactId>cloud-demo</artifactId>
        <groupId>cn.itcast</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>user-service</artifactId>

    <dependencies>
        <!-- Spring工程的web启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
        </dependency>
    </dependencies>


</project>

4.2.3编写配置文件application.yml

server:
  port: 8081
spring:
  datasource:
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql://localhost/yum6
      username: root
      password: 123456
mybatis:
  type-aliases-package: cn.itcast.user.pojo

创建cn.itcast.user.pojo包

4.2.4编写代码

4.2.4.1启动类

包：cn.itcast
类：UserApplication

package cn.itcast;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("cn.itcast.user.mapper")
public class UserApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserApplication.class);
    }
    
}

4.2.4.2实体类

包：cn.itcast.user.pojo
类：User

package cn.itcast.user.pojo;

import lombok.Data;
import tk.mybatis.mapper.annotation.KeySql;

import javax.persistence.Id;
import javax.persistence.Table;
import java.util.Date;

@Data
@Table(name="tb_user")
public class User {
    //id
    @Id
    @KeySql(useGeneratedKeys = true)
    private Long id;
    //用户名
//    @Column(name = "username")
    private String username;
    //密码
    private String password;
    private String phone;
    private Date created;

}

4.2.4.3Mapper

包：cn.itcast.user.mapper
类：UserMapper
使用通用Mapper

package cn.itcast.user.mapper;

import cn.itcast.user.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import tk.mybatis.mapper.common.Mapper;

public interface UserMapper extends Mapper<User> {
}

4.2.4.4Service

包：cn.itcast.user.service
类：UserService

package cn.itcast.user.service;

import cn.itcast.user.mapper.UserMapper;
import cn.itcast.user.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;
    public User queryById(Long id){
        return userMapper.selectByPrimaryKey(id);
    }
}

4.2.4.5Controller

包：cn.itcast.user.controller
类：UserController

package cn.itcast.user;

import cn.itcast.user.pojo.User;
import cn.itcast.user.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("user")
public class Controller {
    @Autowired
    private UserService userService;

    //@PathVariable是spring3.0的一个新功能：接收请求路径中占位符的值
    @GetMapping("/{id}")
    public User queryById(@PathVariable("id") Long id){
        return userService.queryById(id);
    }
}

4.2.4.6测试

http://localhost:8081/user/16访问成功！！

4.3服务调用者

4.3.1创建工程

4.3.2引入依赖

该项目作为调用者，不需要再访问数据库了，他是调用服务方user-service。所以在引入依赖时只需要引入web启动器就可以了。
加入依赖：

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

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">
    <parent>
        <artifactId>cloud-demo</artifactId>
        <groupId>cn.itcast</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

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

4.3.3编写代码

4.3.3.1启动类

包：cn.itcast
类：ConsumerApplication

package cn.itcast;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;
//启动类
@SpringBootApplication
public class ConsumerApplication {
    //需要调用，所以需要这个对象
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class,args);
    }
}

4.3.3.2实体类

因为不需要数据库了，所以实体类中不需要@Table、@Id等一些通用Mapper映射注解了。

package cn.itcast.consumer.pojo;

import lombok.Data;
import java.util.Date;

@Data
public class User {
    //id
    private Long id;
    //用户名
//    @Column(name = "username")
    private String username;
    //密码
    private String password;
    private String phone;
    private Date created;

}

4.3.3.3Controller

包：cn.itcast.consumer.web
类：ConsumerController

package cn.itcast.consumer.web;

import cn.itcast.consumer.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
@RequestMapping("consumer")
public class ConsumerController {
    @Autowired
    private RestTemplate restTemplate;
    @GetMapping("{id}")
    public User queryById(@PathVariable("id") Long id){
        String url = "http://localhost:8081/user/"+id;
        User user = restTemplate.getForObject(url, User.class);
        return user;
    }
}

4.3.4测试

http://localhost:8080/consumer/17访问成功！！

4.4流程图

4.5这样调用有没有问题？

服务的调用中地址写死了。若是发生服务迁移或地址被占用，就无法调用了。若是部署集群，写死了就只访问一个，无法访问其他的。

在consumer中，我们把url地址硬编码到了代码中，不方便后期维护。
consumer需要记忆user-service的地址，如果出现变更，可能得不到通知，地址将失效。
consumer不清楚user-service的状态，服务宕机也不知道。
user-service只有1台服务，不具备高可用性。
即便user-service形成集群，consumer还需自己实现负载均衡。

其实上面说的问题，概括一下就是分布式服务必然要面临的问题：

服务管理
- 如何自动注册和发现
- 如何实现状态监管
- 如何实现动态路由
服务如何实现负载均衡
服务如何解决容灾问题
服务如何实现统一配置

5.Eureka注册中心

5.1原理图

Eureka：服务注册中心（可以是一个集群），对外暴露自己的地址。
提供者：启动后想Eureka注册自己信息（地址，提供什么服务）。
消费者：向Eureka订阅服务，Eureka会将对应服务的所有提供者的地址列表发送给消费者。并且定期更新。
心跳（续约）：提供者定期通过http方式向Eureka刷新自己的状态。

注：消费者是拉取服务列表，而不是注册中心向消费者推送服务列表。

5.2 入门案例

5.2.1创建项目

创建项目：

5.2.2引入依赖

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

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">
    <parent>
        <artifactId>cloud-demo</artifactId>
        <groupId>cn.itcast</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

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


</project>

该依赖已经将Eureka服务的注册发现等所有功能都实现了。

5.2.3配置application.yml

因为前面user-service占用端口8081；
consumer-service占用端口8080；
所以想要启动该项目，需要为它配置端口，比如配置为10086。

server:
  port: 10086

5.2.4编写EurekaServer启动类

包：cn.itcast
类： EurekaServer

package cn.itcast;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@EnableEurekaServer
@SpringBootApplication
public class EurekaServer {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServer.class);
    }
}

@EnableEurekaServer：启动Eureka的服务。

5.2.5测试

http://localhost:10086/
会出现以下问题：

问题一：

启动时报错，可以忽略，它是可以进入注册中心。但是进入后也一直在报错。

注意：
作为一个注册中心，也不能挂，也应该搭建成集群。所以他即是一个服务器，但其实也是客户端。

原因：
此时没有人注册，所以会报错。
解决方案：
要设置自己注册自己。
在application.yml中添加如下配置：

eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka

再次启动：
访问http://localhost:10086/

问题二：

问题：服务名未知
解决方案：在application.yml配置中添加如下：

spring:
  application:
    name: eureka-server

访问http://localhost:10086/

问题三：

出现的不是ip

解决方法：
在application.yml中添加如下配置

eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka
  instance:
    prefer-ip-address: true
    ip-address: 127.0.0.1

5.4修改项目

5.4.1服务方：user-service子项目

5.4.1.1引入依赖

<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            <version>2.1.0.RELEASE</version>
        </dependency>

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">
    <parent>
        <artifactId>cloud-demo</artifactId>
        <groupId>cn.itcast</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>user-service</artifactId>

    <dependencies>
        <!-- Spring工程的web启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            <version>2.1.0.RELEASE</version>
        </dependency>
    </dependencies>
</project>

5.4.1.2修改启动类UserApplication

在类上添加注解**@EnableDiscoveryClient**

为什么使用@EnableDiscoveryClient？

答：现在我们使用的注册中心是Eureka，但是springcloud内置的注册中心不止一种，它不仅支持Eureka，也支持zookeper等好几种。当添加注解是@@EnableEurekaClient的时候，将来只能注册到Eureka注册中心。但是用@EnableDiscoveryClient注解，更加通用，即注解的对应服务也是客服端，但是内部既能兼容Eureka，也能兼容Zookeper等。

package cn.itcast;


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import tk.mybatis.spring.annotation.MapperScan;

@EnableDiscoveryClient
@SpringBootApplication
@MapperScan("cn.itcast.user.mapper")
public class UserApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserApplication.class);
    }
}

5.4.1.3修改application.yml

完整的application.yml内容：

server:
  port: 8081
spring:
  application:
    name: user-service
  datasource:
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql://localhost/yum6
      username: root
      password: 123456
mybatis:
  type-aliases-package: cn.itcast.user.pojo

eureka:
  client:
    service-url: 
      defaultZone: http://127.0.0.1:10086/eureka

5.4.1.3测试

启动user-service
访问http://localhost:10086/

5.4.2调用方：consumer-service子项目

5.4.2.1引入依赖

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

5.4.2.2在启动类上加注解

@EnableDiscoveryClient

package cn.itcast;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;
//启动类
@EnableDiscoveryClient
@SpringBootApplication
public class ConsumerApplication {
    //需要调用，所以需要这个对象
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class,args);
    }
}

5.4.2.2添加配置application.yml

将该项目改为8088

server:
  port: 8088
spring:
  application:
    name: consumer-service
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka

5.4.2.3测试

5.5消费者动态从Eureka获取服务

因为大家都是客户端，所以服务的提供者也有可能消费者，服务的消费者也有可能是提供者。
服务者可能会部署成集群，开启很多个tomcat，但是这些服务者的服务名都是一样的，所以在不同tomcat上部署的同一个服务就叫做服务的实例。

5.5.1添加依赖

若pom.xml不存在下面依赖，就添加进去。

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

5.5.2编写测试类

package cn.itcast.consumer.web;

import cn.itcast.consumer.pojo.User;
import com.netflix.appinfo.InstanceInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
@RequestMapping("consumer")
public class ConsumerController {
    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private DiscoveryClient discoveryClient;
    @GetMapping("{id}")
    public User queryById(@PathVariable("id") Long id){
        //根据服务id获取实例
        List<ServiceInstance> instances = discoveryClient.getInstances("user-service");
        // 因为只有一个UserService,因此我们直接get(0)获取
        ServiceInstance instance = instances.get(0);
        //从实例中取出ip和端口
        String url = instance.getHost();
        int port = instance.getPort();
        String baseUrl = "http://"+instance.getHost() + ":" + instance.getPort()+"/user/"+id;
        User user = restTemplate.getForObject(baseUrl, User.class);
        return user;
    }
}

此处测试只有一个服务，所以直接instances.get(0)。但是以后需要些负载均衡算法。

5.5.3测试

http://localhost:8088/consumer/19访问成功！

5.6Eureka详解

5.6.1基础架构

EurekaServer也是可以是一个集群，形成高可用的Eureka中心。
说个Eureka Server之间会互相注册为服务。当服务提供者注册到Eureka Server集群中的某个节点时，该节点会把服务的信息同步给集群中的每个节点，从而实现数据同步。因此，无论客户端访问到Eureka Server集群中的任意一个节点，都可以获取到完整的服务列表信息。

如果有三个Eureka，则每一个Eureka Server都需要注册到其他几个Eureka服务中。

5.6.2高可用的Eureka Server小demo

先修改eureka-server

复制上述eureka-server项目

此时复制的这个eureka称为eureka-server2由于无法更改，所以就需要改原先的eureka-server项目。
要注意：因为eureka-server的端口号配置过，为10086，此时变成为eureka-server2的端口，即10086。
所以eureka-server的端口需要改为10087。

总结理解：
eureka-server:
端口10087，向eureka-server2注册。

eureka-server2:
端口10086，向eureka-server注册

若是其中一台eureka挂了，要想不影响访问，需要修改user-service、consumer-service的application.yml配置文件。
改为：向两个eureka都注册。多个地址使用“，”隔开。

eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka,http://127.0.0.1:10087/eureka

5.6.3Eureka客户端

5.6.3.1服务的注册和发现时长配置

服务注册

服务提供者在启动时，会检测属性配置中的：eureka.client.register-with-erueka=true参数是否正确。事实上默认就是true。如果值确实为true，则会向EurekaServer发起一个Rest请求，并携带自己的元数据信息。会把这些信息保存在一个双层Map结构中。

第一层Map的Key就是服务id，一般是配置中spring.application.name属性。
第二层Map的key是服务的实例id，一般是配置中的实例id，一般host+serviceid+port，例如：locahost:user-service:8081。
值则是服务的实例对象，也就是说一个服务，可以同时启动多个不同实例。形成集群。

服务续约

在注册服务完成以后，服务提供者会维持一个心跳（定时向EurekaServer发起Rest请求），告诉EurekaServer：“我还活着”，这个我们成为服务的续约（renew）。
心跳续约默认时间是30s，每隔30s进行一次心跳。也可配置。
eureka:
instance:
#每隔30s发送一次心跳
lease-renewal-interval-in-seconds: 30
#最小过期时长，每隔30秒发一次心跳，如果隔了90s还没有发送心跳，就挂了
lease-expiration-duration-in-seconds: 90

服务列表拉取

当服务消费者启动时，会检测eureka.client.fetch-registry=true参数的值，如果为true，则会从Eureka Server服务的列表只读备份，然后缓存到本地，并且每隔30s会重新获取并更新数据。

eureka:
  client:
    #要不要拉取服务
    fetch-registry: true
    #拉取周期
    registry-fetch-interval-seconds: 3

5.6.3.2失效剔除和自我保护

服务下线

当服务进行正常关闭操作时，它会出发一个服务下线的Rest请求给Eureka Server，告诉服务注册中心：“我要下线了”。服务中心接收到请求之后，将该服务置为下线状态。

失效剔除

有时服务可能由于内存溢出或网络故障灯原因使得服务不能正常工作，而服务注册中心并未收到“服务下线”的请求，相对于服务提供者的“服务续约”操作，服务注册中心在启动时会创建一个定时任务，默认每个一段时间（默认为60s）将当前清单中超时（默认90s）没有续约的服务剔除，这个操作被称为失效剔除。
可以通过eureka.server.eviction-interval-time-in-ms参数对其进行修改，单位是毫秒。
配置到eureka中。

eureka:
  server:
    eviction-interval-timer-in-ms: 300000

自我保护

当服务未按时进行心跳续约时，Eureka会统计服务实例最近15分钟心跳续约的比例是否低于85%，在生产环境下，因为网络延迟等原因，心跳失败实例有可能超标，但是此时就把服务删除列表并不妥当，因为服务可能没有宕机，Eureka在这段时间内不会删除任何服务实例，直到网络恢复正常。
生产环境下这很有效，保证了大多数服务依然可用，不过可由可能获取到失败的服务实例，因此服务调用者必须做好服务的失败容错。
可以通过下面配置关停自我保护。

eureka:
  server:
    enable-self-preservation: false

6.负载均衡Ribbon

修改前：是只取第一个实例：

package cn.itcast.consumer.web;

import cn.itcast.consumer.pojo.User;
import com.netflix.appinfo.InstanceInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
@RequestMapping("consumer")
public class ConsumerController {
    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private DiscoveryClient discoveryClient;
    @GetMapping("{id}")
    public User queryById(@PathVariable("id") Long id){
        //根据服务id获取实例
        List<ServiceInstance> instances = discoveryClient.getInstances("user-service");
        // 因为只有一个UserService,因此我们直接get(0)获取
        ServiceInstance instance = instances.get(0);
        //从实例中取出ip和端口
        String url = instance.getHost();
        int port = instance.getPort();
        String baseUrl = "http://"+instance.getHost() + ":" + instance.getPort()+"/user/"+id;
        System.out.println(baseUrl);
        User user = restTemplate.getForObject(baseUrl, User.class);
        return user;
    }
}

修改后：应该变成随机、轮询、hash等负载算法

6.1优化user-service微服务

6.1.1复制项目

使提供者有多个实例。

6.1.2在consumer-service引入依赖

<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
        </dependency>

6.1.3修改ConsumerApplication启动类

在RestTemplate方法上加注解@LoadBalanced

package cn.itcast;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;
//启动类
@EnableDiscoveryClient
@SpringBootApplication
public class ConsumerApplication {
    //需要调用，所以需要这个对象
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class,args);
    }
}

将来它会内置拦截器，用来拦截器RestTemplat请求。

6.1.4修改ConsumerController

package cn.itcast.consumer.web;

import cn.itcast.consumer.pojo.User;
import com.netflix.appinfo.InstanceInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
@RequestMapping("consumer")
public class ConsumerController {
    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private DiscoveryClient discoveryClient;
    //最终方案
    @GetMapping("{id}")
    public User queryById(@PathVariable("id") Long id){
        //user-service是服务id
        String url = "http://user-service/user/"+id;
        User user = restTemplate.getForObject(url, User.class);
        return user;
    }
    
   /* 方法一：
    @Autowired
    private RibbonLoadBalancerClient client;

    //修改后
    @GetMapping("{id}")
    public User queryById(@PathVariable("id") Long id){

        //根据服务id获取实例，该方法帮我们实现了负载均衡，默认是轮询。
        ServiceInstance instance = client.choose("user-service"）；
          ...
        User user = restTemplate.getForObject(baseUrl, User.class);
        return user;
    }
    */

/*    修改前
    @GetMapping("{id}")
    public User queryById(@PathVariable("id") Long id){
        //根据服务id获取实例
        List instances = discoveryClient.getInstances("user-service");
        // 因为只有一个UserService,因此我们直接get(0)获取
        ServiceInstance instance = instances.get(0);
        //从实例中取出ip和端口
        String url = instance.getHost();
        int port = instance.getPort();
        String baseUrl = "http://"+instance.getHost() + ":" + instance.getPort()+"/user/"+id;
        System.out.println(baseUrl);
        User user = restTemplate.getForObject(baseUrl, User.class);
        return user;
    }*/
}

6.1.4测试

http://localhost:8088/consumer/17
访问成功！

6.1.5负载均衡策略

负载均衡默认通过轮询规则，若不想使用轮询，可通过以下配置使用其他规则。
在consumer-service的application.yml中配置

user-service:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule
    #随机

格式：
服务名称。ribbon.NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

7.Hystrix

是一种保护机制。
也是Netflix公司的一款组件。

7.1雪崩问题

微服务中，服务间调用关系错综复杂，一个请求，可能需要调用多个微服务接口才能实现，会形成非常复杂的使用链路。

例如，一次业务请求，需要调用A、B、C、D四个服务，这四个服务可能又调用其他服务。此时，若某个服务发生异常，请求阻塞，用户不会得到想用。而tomcat这个线程不会释放，于是越来越多的用户请求被阻塞，会慢慢占满tomcat可用连接，从而导致其他所有服务都不可用，形成雪崩效应。

Hystrix解决雪崩问题的手段有两个：

线程隔离
服务熔断

7.2 线程隔离，服务降级

每个服务有独立的线程池，例如，为一个服务设置5个线程，当用户请求该服务，出现阻塞时，就只会阻塞他自己的这5个线程，不影响其他。即只占满自己的线程池，这就是线程隔离。

当访问的这个服务线程池占满时，也不会出现无线阻塞，会设置一个时间，在时间内没有得到相应，会返回一个响应到浏览器，该请求会释放，释放线程。这就是服务降级。

总结：
Hystrix为每个依赖服务调用分配一个小的线程池，如果线程池已满调用将被立即拒绝，默认不采用排队，加速失败判定时间。
用户的请求将不再直接访问服务，而是通过线程池中的空闲线程访问服务，如果线程池已满，或者请求超时，则会进行降级处理。
服务降级虽然会导致请求失败，但不会导致阻塞，而且最多会影响这个依赖服务对应的线程池中的资源，对其他服务没有响应。
触发服务降级的情况：

线程池已满
请求超时

7.2.1实践

7.2.1.1引入依赖

在消费方配置，在consumer-service中添加依赖：

<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

7.2.1.2启用熔断

在启动类上添加注解
@EnableCircuitBreaker

package cn.itcast;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;
//启动类
@EnableCircuitBreaker
@EnableDiscoveryClient
@SpringBootApplication
public class ConsumerApplication {
    //需要调用，所以需要这个对象
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class,args);
    }
}

标准的服务上都要添加
@EnableCircuitBreaker
@EnableDiscoveryClient
@SpringBootApplication这三个注解，因此springcloud提供给我们一个新的注解@SpringCloudApplication可以替代这三个注解。

package cn.itcast;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.SpringCloudApplication;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;
//启动类
//@EnableCircuitBreaker
//@EnableDiscoveryClient
//@SpringBootApplication
@SpringCloudApplication
public class ConsumerApplication {
    //需要调用，所以需要这个对象
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class,args);
    }
}

7.2.1.3修改ConsumerController

package cn.itcast.consumer.web;

import cn.itcast.consumer.pojo.User;
import com.netflix.appinfo.InstanceInfo;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
@RequestMapping("consumer")
public class ConsumerController {
    @Autowired
    private RestTemplate restTemplate;
    //集群+失败处理=最终方案
    //失败容错的指令,即成功时使用该方法，失败时调用注解中参数指的方法。要求失败和成功时的两个方法返回值和参数完全一样
    @HystrixCommand(fallbackMethod = "queryByIdFallback" )
    @GetMapping("{id}")
    public String queryById(@PathVariable("id") Long id){
        //user-service是服务id
        String url = "http://user-service/user/"+id;
        //返回的对象转成json字符串
        String user = restTemplate.getForObject(url, String.class);
        return user;
    }

    public String queryByIdFallback(@PathVariable("id") Long id){
        return "不好意思，服务器太拥挤了！";
    }

    /*//集群最终方案
    @GetMapping("{id}")
    public User queryById(@PathVariable("id") Long id){
        //user-service是服务id
        String url = "http://user-service/user/"+id;
        User user = restTemplate.getForObject(url, User.class);
        return user;
    }*/

   /* 方法一：
    @Autowired
    private RibbonLoadBalancerClient client;

    //修改后
    @GetMapping("{id}")
    public User queryById(@PathVariable("id") Long id){

        //根据服务id获取实例，该方法帮我们实现了负载均衡，默认是轮询。
        ServiceInstance instance = client.choose("user-service"）；
          ...
        User user = restTemplate.getForObject(baseUrl, User.class);
        return user;
    }
    */

/*    修改前
    @Autowired
    private DiscoveryClient discoveryClient;
    @GetMapping("{id}")
    public User queryById(@PathVariable("id") Long id){
        //根据服务id获取实例
        List instances = discoveryClient.getInstances("user-service");
        // 因为只有一个UserService,因此我们直接get(0)获取
        ServiceInstance instance = instances.get(0);
        //从实例中取出ip和端口
        String url = instance.getHost();
        int port = instance.getPort();
        String baseUrl = "http://"+instance.getHost() + ":" + instance.getPort()+"/user/"+id;
        System.out.println(baseUrl);
        User user = restTemplate.getForObject(baseUrl, User.class);
        return user;
    }*/


}

7.2.1.4模拟测试

修改UserService模拟熔断环境。

public class UserService {
    @Autowired
    private UserMapper userMapper;
    public User queryById(Long id){
        try {
            Thread.sleep(2000l);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return userMapper.selectByPrimaryKey(id);
    }

}

7.2.1.4优化代码

问题一：

由于上述失败是调用方法是为其中一个方法写的，但是以后有许多方法，总不能为每个方法都要写一个失败时调用方法，此时就要优化代码。

package cn.itcast.consumer.web;

import cn.itcast.consumer.pojo.User;
import com.netflix.appinfo.InstanceInfo;
import com.netflix.hystrix.contrib.javanica.annotation.DefaultProperties;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
@RequestMapping("consumer")
//该类中所有方法默认失败时调用方法
@DefaultProperties(defaultFallback = "@DefaultProperties(defaultFallback = queryByIdFallback)\n")
public class ConsumerController {
    @Autowired
    private RestTemplate restTemplate;
    //集群+失败处理=最终方案
    //启用降级和线程隔离，一旦失败，会去找@DefaultProperties中配置的方法
    @HystrixCommand
    @GetMapping("{id}")
    public String queryById(@PathVariable("id") Long id){
        //user-service是服务id
        String url = "http://user-service/user/"+id;
        //返回的对象转成json字符串
        String user = restTemplate.getForObject(url, String.class);
        return user;
    }

    public String queryByIdFallback(){
        return "不好意思，服务器太拥挤了！";
    }
  /*  //方法一：
    //集群+失败处理
    //失败容错的指令,即成功时使用该方法，失败时调用注解中参数指的方法。要求失败和成功时的两个方法返回值和参数完全一样
    @HystrixCommand(fallbackMethod = "queryByIdFallback" )
    @GetMapping("{id}")
    public String queryById(@PathVariable("id") Long id){
        //user-service是服务id
        String url = "http://user-service/user/"+id;
        //返回的对象转成json字符串
        String user = restTemplate.getForObject(url, String.class);
        return user;
    }*/

    /*//最终方案
    @GetMapping("{id}")
    public User queryById(@PathVariable("id") Long id){
        //user-service是服务id
        String url = "http://user-service/user/"+id;
        User user = restTemplate.getForObject(url, User.class);
        return user;
    }*/

   /* 方法一：
    @Autowired
    private RibbonLoadBalancerClient client;

    //修改后
    @GetMapping("{id}")
    public User queryById(@PathVariable("id") Long id){

        //根据服务id获取实例，该方法帮我们实现了负载均衡，默认是轮询。
        ServiceInstance instance = client.choose("user-service"）；
          ...
        User user = restTemplate.getForObject(baseUrl, User.class);
        return user;
    }
    */

/*    修改前
    @Autowired
    private DiscoveryClient discoveryClient;
    @GetMapping("{id}")
    public User queryById(@PathVariable("id") Long id){
        //根据服务id获取实例
        List instances = discoveryClient.getInstances("user-service");
        // 因为只有一个UserService,因此我们直接get(0)获取
        ServiceInstance instance = instances.get(0);
        //从实例中取出ip和端口
        String url = instance.getHost();
        int port = instance.getPort();
        String baseUrl = "http://"+instance.getHost() + ":" + instance.getPort()+"/user/"+id;
        System.out.println(baseUrl);
        User user = restTemplate.getForObject(baseUrl, User.class);
        return user;
    }*/


}

问题二：

现在是把所有超时统一定义，超时时长1s。但是不同业务其超时时长应该不一样。对于速度慢的，应该单独为其设置超时时长。

单独配：

该注解方法用来单独配置在方法上。
@HystrixCommand(commandProperties = {
@HystrixProperty(name = “execution.isolation.thread.timeoutInMilliseconds”,value = “3000”)

package cn.itcast.consumer.web;

import com.netflix.hystrix.contrib.javanica.annotation.DefaultProperties;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
@RequestMapping("consumer")
//该类中所有方法默认失败时调用方法
@DefaultProperties(defaultFallback = "queryByIdFallback")
public class ConsumerController {
    @Autowired
    private RestTemplate restTemplate;
    //集群+失败处理=最终方案
    //启用降级和线程隔离，一旦失败，会去找@DefaultProperties中配置的方法
    @HystrixCommand(commandProperties = {
            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds",value = "3000")
    })
    @GetMapping("{id}")
    public String queryById(@PathVariable("id") Long id){
        //user-service是服务id
        String url = "http://user-service/user/"+id;
        //返回的对象转成json字符串
        String user = restTemplate.getForObject(url, String.class);
        return user;
    }

    public String queryByIdFallback(){
        return "不好意思，服务器太拥挤了！";
    }
  /*  //方法一：
    //集群+失败处理
    //失败容错的指令,即成功时使用该方法，失败时调用注解中参数指的方法。要求失败和成功时的两个方法返回值和参数完全一样
    @HystrixCommand(fallbackMethod = "queryByIdFallback" )
    @GetMapping("{id}")
    public String queryById(@PathVariable("id") Long id){
        //user-service是服务id
        String url = "http://user-service/user/"+id;
        //返回的对象转成json字符串
        String user = restTemplate.getForObject(url, String.class);
        return user;
    }*/

    /*//最终方案
    @GetMapping("{id}")
    public User queryById(@PathVariable("id") Long id){
        //user-service是服务id
        String url = "http://user-service/user/"+id;
        User user = restTemplate.getForObject(url, User.class);
        return user;
    }*/

   /* 方法一：
    @Autowired
    private RibbonLoadBalancerClient client;

    //修改后
    @GetMapping("{id}")
    public User queryById(@PathVariable("id") Long id){

        //根据服务id获取实例，该方法帮我们实现了负载均衡，默认是轮询。
        ServiceInstance instance = client.choose("user-service"）；
          ...
        User user = restTemplate.getForObject(baseUrl, User.class);
        return user;
    }
    */

/*    修改前
    @Autowired
    private DiscoveryClient discoveryClient;
    @GetMapping("{id}")
    public User queryById(@PathVariable("id") Long id){
        //根据服务id获取实例
        List instances = discoveryClient.getInstances("user-service");
        // 因为只有一个UserService,因此我们直接get(0)获取
        ServiceInstance instance = instances.get(0);
        //从实例中取出ip和端口
        String url = instance.getHost();
        int port = instance.getPort();
        String baseUrl = "http://"+instance.getHost() + ":" + instance.getPort()+"/user/"+id;
        System.out.println(baseUrl);
        User user = restTemplate.getForObject(baseUrl, User.class);
        return user;
    }*/


}

之前设置的是2s的睡眠时间，但在这里设置的是3s超时时长，睡眠时间没有超过2s，所以可以访问成功。

整理配置：
配置在application.yml文件上。


hystrix:
  command:
  #配置全局变量
    default:
      execution:
        isolation:
          thread:
           timeoutInMilliseconds: 3000
  #配置单个方法或服务的变量
 # user-service：或者queryByIdFallback
 	# execution:
     #   isolation:
      #    thread:
       #    timeoutInMilliseconds: 3000

7.3服务熔断

7.3.1熔断原理

熔断其英文单词：Circuit Breaker
像家里的点了熔断器，如果点了发生短路能立刻熔断电路，避免发生灾难。在分布式系统应用这一模块之后，服务调用方可以自己进行判断某些服务反映慢或者存在大量超时的情况时，能够主动熔断，防止整个系统被拖垮。

不同于电路熔断只能断不能自动重连，Hystrix可以实现弹性容错，当情况好转之后，可以自动重连。

通过断路的方式，可以将后续请求直接拒绝掉，一段时间之后允许部分请求通过，如果调用成功回到正常状态，否则连续断开。

熔断器的三个状态：

closed：熔断器关闭，所有请求正常访问，会直接返回失败。
open：熔断器打开，所有请求都会被降级。然后Hystix会对请求情况计数，当一定时间内失败请求百分比达到阈值，则触发熔断，熔断器完全关闭，默认失败比例的阈值是50%，请求次数两不低于20次。
half open：半开状态。closed状态不是永久的，关闭后会进入休眠时间（默认是5s），随后熔断器会自动进入半开状态，此时会释放部分请求通过，若这些请求都是健康的，则会完全打开熔断器，否则持续关闭，再次进行休眠。

7.3.2实践

我们通过手动控制，不需要通过休眠时间。若访问id为偶数，则请求失败，奇数则成功。

7.3.2.1修改UserService

把之前模拟的休眠代码删掉。

package cn.itcast.user.service;

import cn.itcast.user.mapper.UserMapper;
import cn.itcast.user.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;
    public User queryById(Long id){
        /*try {
            Thread.sleep(2000l);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }*/
        return userMapper.selectByPrimaryKey(id);
    }

}

7.3.2.1修改ConsumerController

模拟测试环境，并设置休眠时间为10s，当熔断器关闭后，访问次数设置为10次，超过50%失败则进入休眠时间。休眠时间一过，释放部分连接，若请求成功，则关闭熔断器，否则进入休眠时间。

package cn.itcast.consumer.web;

import com.netflix.hystrix.contrib.javanica.annotation.DefaultProperties;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
@RequestMapping("consumer")
//该类中所有方法默认失败时调用方法
@DefaultProperties(defaultFallback = "queryByIdFallback")
public class ConsumerController {
    @Autowired
    private RestTemplate restTemplate;
    //集群+失败处理=最终方案
    //启用降级和线程隔离，一旦失败，会去找@DefaultProperties中配置的方法
    @HystrixCommand(commandProperties = {
            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds",value = "3000"),
            //熔断器关闭后，失败次数
            @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold",value = "10"),
            //熔断器关闭后，休眠时间
            @HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds",value = "10000"),

    })
    @GetMapping("{id}")
    public String queryById(@PathVariable("id") Long id){
        //模拟熔断环境测试,id为偶数即请求失败，为奇数就成功
        if(id%2 == 0){
            throw new RuntimeException("");
        }
        //user-service是服务id
        String url = "http://user-service/user/"+id;
        //返回的对象转成json字符串
        String user = restTemplate.getForObject(url, String.class);
        return user;
    }

    public String queryByIdFallback(){
        return "不好意思，服务器太拥挤了！";
    }

生产环境下，这些参数不需要调，按照默认的就可以了。

总结：该篇讲了服务间的访问和高可用。

你可能感兴趣的:(#,java,开发)

【iOS】MVC设计模式 Magnetic_h ios mvc 设计模式 objective-c 学习 ui
MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
UI学习——cell的复用和自定义cell Magnetic_h ui 学习
目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
linux sdl windows.h,Windows下的SDL安装奔跑吧linux内核 linux sdl windows.h
首先你要下载并安装SDL开发包。如果装在C盘下，路径为C:\SDL1.2.5如果在WINDOWS下。你可以按以下步骤：1.打开VC++，点击"Tools",Options2,点击directories选项3.选择"Includefiles"增加一个新的路径。"C:\SDL1.2.5\include"4，现在选择"Libaryfiles“增加"C:\SDL1.2.5\lib"现在你可以开始编写你的第
PHP环境搭建详细教程好看资源平台前端 php
PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器）编程经验分享开发工具服务器 ssh linux
目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
关于提高复杂业务逻辑代码可读性的思考编程经验分享开发经验 java 数据库开发语言
目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
【加密社】Solidity 中的事件机制及其应用加密社闲侃区块链智能合约区块链
加密社引言在Solidity合约开发过程中，事件（Events）是一种非常重要的机制。它们不仅能够让开发者记录智能合约的重要状态变更，还能够让外部系统（如前端应用）监听这些状态的变化。本文将详细介绍Solidity中的事件机制以及如何利用不同的手段来触发、监听和获取这些事件。事件存储的地方当我们在Solidity合约中使用emit关键字触发事件时，该事件会被记录在区块链的交易收据中。具体而言，事件
使用Faiss进行高效相似度搜索 llzwxh888 faiss python
在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
利用Requests Toolkit轻松完成HTTP请求 nseejrukjhad http 网络协议网络 python
RequestsToolkit的力量：轻松构建HTTP请求Agent在现代软件开发中，API请求是与外部服务交互的核心。RequestsToolkit提供了一种便捷的方式，帮助开发者构建自动化的HTTP请求Agent。本文旨在详细介绍RequestsToolkit的设置、使用和潜在挑战。引言RequestsToolkit是一个强大的工具包，可用于构建执行HTTP请求的智能代理。这对于想要自动化与外
利用LangChain的StackExchange组件实现智能问答系统 nseejrukjhad langchain microsoft 数据库 python
利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
在一台Ubuntu计算机上构建Hyperledger Fabric网络落叶无声9 区块链超级账本 Hyperledger fabric 区块链 ubuntu 构建 hyperledger fabric
在一台Ubuntu计算机上构建HyperledgerFabric网络Hyperledgerfabric是一个开源的区块链应用程序平台，为开发基于区块链的应用程序提供了一个起点。当我们提到HyperledgerFabric网络时，我们指的是使用HyperledgerFabric的正在运行的系统。即使只使用最少数量的组件，部署Fabric网络也不是一件容易的事。Fabric社区创建了一个名为Cello
GitHub上克隆项目 bigbig猩猩 github
从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
Faiss Tips：高效向量搜索与聚类的利器焦习娜Samantha
FaissTips：高效向量搜索与聚类的利器faiss_tipsSomeusefultipsforfaiss项目地址:https://gitcode.com/gh_mirrors/fa/faiss_tips项目介绍Faiss是由FacebookAIResearch开发的一个用于高效相似性搜索和密集向量聚类的库。它支持多种硬件平台，包括CPU和GPU，能够在海量数据集上实现快速的近似最近邻搜索（AN
pyecharts——绘制柱形图折线图 2224070247 信息可视化 python java 数据可视化
一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
CX8903：Ebike自行车仪表电源方案开发,Ebike智能仪表电源芯片诚芯微科技社交电子
CX8903：电动Ebike自行车仪表电源方案开发,Ebike智能仪表电源芯片推荐。电动助力自行车EBIKE凭借其环保、健康、低噪、和便捷等特点，成为了越来越受欢迎的骑行便利交通工具。提供电动Ebike自行车仪表电源方案开发、E-BIKE电动助力自行车仪表供电电源解决方案。CX8903采用100V高压制造工艺（芯片最高耐压可到100V以上），SOP-8L贴片封装，CX8903内置100V/90mΩ
CX8836：小体积大功率升降压方案推荐（附Demo设计指南）诚芯微科技社交电子
CX8836是一颗同步四开关单向升降压控制器，在4.5V-40V宽输入电压范围内稳定工作，持续负载电流10A，能够在输入高于或低于输出电压时稳定调节输出电压，可适用于USBPD快充、车载充电器、HUB、汽车启停系统、工业PC电源等多种升降压应用场合，为大功率TYPE-CPD车载充电器提供最优解决方案。提供CX8836Demo测试、CX8836样品申请及CX8836方案开发技术支持。CX8836同升
【华为OD技术面试真题 - 技术面】-测试八股文真题题库（1）算法大师华为od 面试 python 算法前端
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.黑盒测试和白盒测试的区别2.假设我们公司现在开发一个类似于微信的软件1.0版本，现在要你测试这个功能：打开聊天窗口，输入文本，限制字数在200字以内。问你怎么提取测试点。功能测试性能测试安全性测试可用性测试跨平台兼容性测试网络环境测试3.接口测试的工具你了解哪些
Python爬虫解析工具之xpath使用详解 eqa11 python 爬虫开发语言
文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
01-Git初识 Meereen Git git
01-Git初识概念：一个免费开源，分布式的代码版本控制系统，帮助开发团队维护代码作用：记录代码内容。切换代码版本，多人开发时高效合并代码内容如何学：个人本机使用：Git基础命令和概念多人共享使用：团队开发同一个项目的代码版本管理Git配置用户信息配置：用户名和邮箱，应用在每次提交代码版本时表明自己的身份命令：查看git版本号git-v配置用户名gitconfig--globaluser.name
基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作 GPJnCrbBdl python 开发语言
基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
Faiss：高效相似性搜索与聚类的利器网络·魚大数据 faiss
Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
摩托车加装车载手机充电usb方案/雅马哈USB充电方案开发诚芯微科技社交电子
长途骑行需要给手机与行车记录仪等设备供电，那么，加装USB充电器就相继在两轮电动车上应用起来了。摩托车加装usb充电方案主要应用于汽车、电动自行车、摩托车、房车、渡轮、游艇等交通工具。提供电动车USB充电器方案/摩托车加装usb充电方案/渡轮加装usb充电方案/游艇加装usb充电方案开发。摩托车加装车载手机充电usb方案、汽车游艇改装四孔面板装双USB车充点烟器5V/4A电动车USB充电器输入4.
web前段跨域nginx代理配置刘正强 nginx cms Web
nginx代理配置可参考server部分 server { listen 80; server_name localhost;
spring学习笔记 caoyong spring
一、概述 a>、核心技术 : IOC与AOP b>、开发为什么需要面向接口而不是实现接口降低一个组件与整个系统的藕合程度，当该组件不满足系统需求时，可以很容易的将该组件从系统中替换掉，而不会对整个系统产生大的影响 c>、面向接口编口编程的难点在于如何对接口进行初始化,(使用工厂设计模式)
Eclipse打开workspace提示工作空间不可用 0624chenhong eclipse
做项目的时候，难免会用到整个团队的代码，或者上一任同事创建的workspace， 1.电脑切换账号后，Eclipse打开时，会提示Eclipse对应的目录锁定，无法访问，根据提示，找到对应目录，G:\eclipse\configuration\org.eclipse.osgi\.manager，其中文件.fileTableLock提示被锁定。解决办法，删掉.fileTableLock文件，重
Javascript 面向对面写法的必要性？一炮送你回车库 JavaScript
现在Javascript面向对象的方式来写页面很流行，什么纯javascript的mvc框架都出来了：ember 这是javascript层的mvc框架哦,不是j2ee的mvc框架我想说的是，javascript本来就不是一门面向对象的语言，用它写出来的面向对象的程序，本身就有些别扭，很多人提到js的面向对象首先提的是：复用性。那么我请问你写的js里有多少是可以复用的，用fu
js array对象的迭代方法换个号韩国红果果 array
1.forEach 该方法接受一个函数作为参数，对数组中的每个元素使用该函数 return 语句失效 function square(num) { print(num, num * num); } var nums = [1,2,3,4,5,6,7,8,9,10]; nums.forEach(square); 2.every 该方法接受一个返回值为布尔类型
对Hibernate缓存机制的理解归来朝歌 session 一级缓存对象持久化
在hibernate中session一级缓存机制中，有这么一种情况：问题描述：我需要new一个对象，对它的几个字段赋值，但是有一些属性并没有进行赋值，然后调用 session.save()方法，在提交事务后，会出现这样的情况： 1：在数据库中有默认属性的字段的值为空 2：既然是持久化对象，为什么在最后对象拿不到默认属性的值？通过调试后解决方案如下：对于问题一，如你在数据库里设置了
WebService调用错误合集 darkranger webservice
Java.Lang.NoClassDefFoundError: Org/Apache/Commons/Discovery/Tools/DiscoverSingleton 调用接口出错，一个简单的WebService import org.apache.axis.client.Call;import org.apache.axis.client.Service; 首先必不可
JSP和Servlet的中文乱码处理 aijuans Java Web
JSP和Servlet的中文乱码处理前几天学习了JSP和Servlet中有关中文乱码的一些问题，写成了博客，今天进行更新一下。应该是可以解决日常的乱码问题了。现在作以下总结希望对需要的人有所帮助。我也是刚学，所以有不足之处希望谅解。一、表单提交时出现乱码：在进行表单提交的时候，经常提交一些中文，自然就避免不了出现中文乱码的情况，对于表单来说有两种提交方式：get和post提交方式。所以
面试经典六问 atongyeye 工作面试
题记：因为我不善沟通，所以在面试中经常碰壁，看了网上太多面试宝典，基本上不太靠谱。只好自己总结，并试着根据最近工作情况完成个人答案。以备不时之需。以下是人事了解应聘者情况的最典型的六个问题： 1 简单自我介绍关于这个问题，主要为了弄清两件事，一是了解应聘者的背景，二是应聘者将这些背景信息组织成合适语言的能力。我的回答：(针对技术面试回答，如果是人事面试，可以就掌
contentResolver.query()参数详解百合不是茶 android query()详解
收藏csdn的博客,介绍的比较详细,新手值得一看 1.获取联系人姓名一个简单的例子，这个函数获取设备上所有的联系人ID和联系人NAME。 [java] view plain copy public void fetchAllContacts() {
ora-00054:resource busy and acquire with nowait specified解决方法 bijian1013 oracle 数据库 kill nowait
当某个数据库用户在数据库中插入、更新、删除一个表的数据，或者增加一个表的主键时或者表的索引时，常常会出现ora-00054:resource busy and acquire with nowait specified这样的错误。主要是因为有事务正在执行（或者事务已经被锁），所有导致执行不成功。 1.下面的语句
web 开发乱码征客丶 spring Web
以下前端都是 utf-8 字符集编码一、后台接收 1.1、 get 请求乱码 get 请求中，请求参数在请求头中；乱码解决方法： a、通过在web 服务器中配置编码格式：tomcat 中，在 Connector 中添加URIEncoding="UTF-8"； 1.2、post 请求乱码 post 请求中，请求参数分两部份， 1.2.1、url？参数，
【Spark十六】： Spark SQL第二部分数据源和注册表的几种方式 bit1129 spark
Spark SQL数据源和表的Schema case class apply schema parquet json JSON数据源准备源数据 {"name":"Jack", "age": 12, "addr":{"city":"beijing&
JVM学习之:调优总结 -Xms -Xmx -Xmn -Xss BlueSkator -Xss -Xmn -Xms -Xmx
堆大小设置JVM 中最大堆大小有三方面限制：相关操作系统的数据模型（32-bt还是64-bit）限制；系统的可用虚拟内存限制；系统的可用物理内存限制。32位系统下，一般限制在1.5G~2G；64为操作系统对内存无限制。我在Windows Server 2003 系统，3.5G物理内存，JDK5.0下测试，最大可设置为1478m。典型设置： java -Xmx355
jqGrid 各种参数详解(转帖) BreakingBad jqGrid
jqGrid 各种参数详解分类：源代码分享个人随笔请勿参考解决开发问题 2012-05-09 20:29 84282人阅读评论(22) 收藏举报 jquery 服务器 parameters function ajax string
读《研磨设计模式》-代码笔记-代理模式-Proxy bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; /* * 下面
应用升级iOS8中遇到的一些问题 chenhbc ios8 升级iOS8
1、很奇怪的问题，登录界面，有一个判断，如果不存在某个值，则跳转到设置界面，ios8之前的系统都可以正常跳转，iOS8中代码已经执行到下一个界面了，但界面并没有跳转过去，而且这个值如果设置过的话，也是可以正常跳转过去的，这个问题纠结了两天多，之前的判断我是在 -(void)viewWillAppear:(BOOL)animated 中写的，最终的解决办法是把判断写在 -(void
工作流与自组织的关系？ comsci 设计模式工作
目前的工作流系统中的节点及其相互之间的连接是事先根据管理的实际需要而绘制好的，这种固定的模式在实际的运用中会受到很多限制，特别是节点之间的依存关系是固定的，节点的处理不考虑到流程整体的运行情况，细节和整体间的关系是脱节的，那么我们提出一个新的观点，一个流程是否可以通过节点的自组织运动来自动生成呢？这种流程有什么实际意义呢？这里有篇论文，摘要是：“针对网格中的服务
Oracle11.2新特性之INSERT提示IGNORE_ROW_ON_DUPKEY_INDEX daizj oracle
insert提示IGNORE_ROW_ON_DUPKEY_INDEX 转自：http://space.itpub.net/18922393/viewspace-752123 在 insert into tablea ...select * from tableb中，如果存在唯一约束，会导致整个insert操作失败。使用IGNORE_ROW_ON_DUPKEY_INDEX提示，会忽略唯一
二叉树:堆 dieslrae 二叉树
这里说的堆其实是一个完全二叉树,每个节点都不小于自己的子节点,不要跟jvm的堆搞混了.由于是完全二叉树,可以用数组来构建.用数组构建树的规则很简单: 一个节点的父节点下标为: (当前下标 - 1)/2 一个节点的左节点下标为: 当前下标 * 2 + 1 &
C语言学习八结构体 dcj3sjt126com c
为什么需要结构体，看代码 # include <stdio.h> struct Student //定义一个学生类型，里面有age, score, sex, 然后可以定义这个类型的变量 { int age; float score; char sex; } int main(void) { struct Student st = {80, 66.6,
centos安装golang dcj3sjt126com centos
#在国内镜像下载二进制包 wget -c http://www.golangtc.com/static/go/go1.4.1.linux-amd64.tar.gz tar -C /usr/local -xzf go1.4.1.linux-amd64.tar.gz #把golang的bin目录加入全局环境变量 cat >>/etc/profile<
10.性能优化-监控-MySQL慢查询 frank1234 性能优化 MySQL慢查询
1.记录慢查询配置 show variables where variable_name like 'slow%' ; --查看默认日志路径查询结果：--不用的机器可能不同 slow_query_log_file=/var/lib/mysql/centos-slow.log 修改mysqld配置文件：/usr /my.cnf[一般在/etc/my.cnf，本机在/user/my.cn
Java父类取得子类类名 happyqing java this 父类子类类名
在继承关系中，不管父类还是子类，这些类里面的this都代表了最终new出来的那个类的实例对象，所以在父类中你可以用this获取到子类的信息！ package com.urthinker.module.test; import org.junit.Test; abstract class BaseDao<T> { public void
Spring3.2新注解@ControllerAdvice jinnianshilongnian @Controller
@ControllerAdvice，是spring3.2提供的新注解，从名字上可以看出大体意思是控制器增强。让我们先看看@ControllerAdvice的实现： @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Component public @interface Co
Java spring mvc多数据源配置 liuxihope spring
转自：http://www.itpub.net/thread-1906608-1-1.html 1、首先配置两个数据库 <bean id="dataSourceA" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close&quo
第12章 Ajax（下） onestopweb Ajax
index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
BW / Universe Mappings blueoxygen BO
BW Element OLAP Universe Element Cube Dimension Class Charateristic A class with dimension and detail objects (Detail objects for key and desription) Hi
Java开发熟手该当心的11个错误 tomcat_oracle java 多线程工作单元测试
#1、不在属性文件或XML文件中外化配置属性。比如，没有把批处理使用的线程数设置成可在属性文件中配置。你的批处理程序无论在DEV环境中，还是UAT（用户验收测试）环境中，都可以顺畅无阻地运行，但是一旦部署在PROD 上，把它作为多线程程序处理更大的数据集时，就会抛出IOException，原因可能是JDBC驱动版本不同，也可能是#2中讨论的问题。如果线程数目可以在属性文件中配置，那么使它成为
推行国产操作系统的优劣 yananay windows linux 国产操作系统
最近刮起了一股风，就是去“国外货”。从应用程序开始，到基础的系统，数据库，现在已经刮到操作系统了。原因就是“棱镜计划”，使我们终于认识到了国外货的危害，开始重视起了信息安全。操作系统是计算机的灵魂。既然是灵魂，为了信息安全，那我们就自然要使用和推行国货。可是，一味地推行，是否就一定正确呢？先说说信息安全。其实从很早以来大家就在讨论信息安全。很多年以前，就据传某世界级的网络设备制造商生产的交