Spring Cloud 学习 (十) Spring Security, OAuth2, JWT

通过 Spring Security + OAuth2 认证和鉴权，每次请求都需要经过 OAuth Server 验证当前 token 的合法性，并且需要查询该 token 对应的用户权限，在高并发场景下会存在性能瓶颈。使用 JWT 的方式，OAuth Server 只验证一次，用户所有信息 (包括权限) 包含在返回的 JWT 中

准备工作

生成公钥、私钥

私钥

在控制台输入命令：

1
keytool -genkeypair -alias spring-jwt -validity 3650 -keyalg RSA -dname "CN=Victor,OU=Karonda,O=Karonda,L=Shenzhen,S=Guangdong,C=CN" -keypass abc123 -storepass abc123 -keystore spring-jwt.jks

各个参数的含义，可以通过命令查看：

1
keytool -genkeypair -help

其中 DName 各个参数代表的意义见： X.500 Distinguished Names

公钥

在控制台输入命令：

1
keytool -list -rfc --keystore spring-jwt.jks | openssl x509 -inform pem -pubkey

会提示输入密码，密码为生成私钥命令里设置的密码

本文生成的公钥：

1
2
3
4
5
6
7
8
9
-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2HvMsVqrx60ESp30Ymx7
3Ce2h24QvG9rciDPl8+SxXRz79akmdRCB4HFhBb655aVAnQMj4SGzKcMyofOUt3o
X9tOPz3Y/B/D5viI3cNPYinyFVMawganROsM1meTFR1SPpL/kZUZqLm9pc8lpgat
LtU73ryioVe7FFndce6ZwTe24L4rK0jzseQ24FxoEQ+g0B1DCXZ4Gi9PwBpxWL6W
AG+/NEFFtOGtIJSIwCYzhGqDfyNaOt7JXYwGiWgh0npO3JVvgQVXBW9AdpT5JVSb
ScYktkqY3o0htsSueyne+FbS+OwBVaBewcswPVbEwa6dxtb0vBsp3pNiSdg7rDea
1QIDAQAB
-----END PUBLIC KEY-----

新建 public.cert 文件保存上面生成的公钥 (要包含公钥的完整信息，即 BEGIN PUBLIC KEY 和 END PUBLIC KEY 部分也要包含在文件中)

Windows 系统需要先安装 OpenSSL: 下载链接

将私钥和公钥分别拷贝到 oauth2-server 和 eureka-client 的 resources 目录下

并在 oauth2-server 和 eureka-client 的 pom 添加配置：

1
2
3
4
5
6
7
8
9
10
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-resources-plugin</artifactId>
    <configuration>
        <nonFilteredFileExtensions>
            <nonFilteredFileExtension>cert</nonFilteredFileExtension>
            <nonFilteredFileExtension>jks</nonFilteredFileExtension>
        </nonFilteredFileExtensions>
    </configuration>
</plugin>

因为密钥文件不需要编译

oauth2-server

修改 Authorization Server 配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
@Configuration
@EnableAuthorizationServer // 开启授权服务
@EnableResourceServer // 需要对外暴露获取和验证 Token 的接口，所以也是一个资源服务
public class OAuth2Config extends AuthorizationServerConfigurerAdapter{

    @Autowired
    private AuthenticationManager authenticationManager;

    @Override
    // 配置客户端信息
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients.inMemory() // 将客户端的信息存储在内存中
                .withClient("eureka-client") // 客户端
                .secret("123456")  // 客户端密码
                .authorizedGrantTypes("client_credentials", "refresh_token", "password")
                .accessTokenValiditySeconds(3600) // 设置 token 过期时间
                .scopes("server");
    }

    @Override
    // 配置授权 token 的节点和 token 服务
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints.tokenStore(tokenStore()) // token 的存储方式
                .authenticationManager(authenticationManager) // 开启密码验证，来源于 WebSecurityConfigurerAdapter
//                .userDetailsService(userServiceDetail); // 读取验证用户的信息
                .tokenEnhancer(jwtTokenEnhancer());
    }

    @Bean
    public TokenStore tokenStore() {

//        return new InMemoryTokenStore();

//        return new JdbcTokenStore(dataSource);

        return new JwtTokenStore(jwtTokenEnhancer());
    }

    @Bean
    protected JwtAccessTokenConverter jwtTokenEnhancer(){
        KeyStoreKeyFactory keyStoreKeyFactory =
                new KeyStoreKeyFactory(new ClassPathResource("spring-jwt.jks")
                        , "abc123".toCharArray()); // abc123 为 password
        JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
        converter.setKeyPair(keyStoreKeyFactory.getKeyPair("spring-jwt")); // spring-jwt 为 alias
        return converter;
    }
}

eureka-client

上一篇文章中的 OAuth2 Client 配置本文用不到，要移除

Resource Server 配置

配置 JWT 转换器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
@Configuration
public class JwtConfig {

    @Autowired
    JwtAccessTokenConverter jwtAccessTokenConverter;

    @Bean
    public TokenStore tokenStore(){
        return new JwtTokenStore(jwtAccessTokenConverter);
    }

    @Bean
    protected JwtAccessTokenConverter jwtTokenEnhancer(){
        JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
        Resource resource = new ClassPathResource("public.cert"); // 公钥

        String publicKey;
        try{
            publicKey = new String(FileCopyUtils.copyToByteArray(resource.getInputStream()));
        }catch (IOException e){
            throw new RuntimeException(e);
        }

        converter.setVerifierKey(publicKey);

        return converter;
    }
}

修改 Resource Server 配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Configuration
@EnableResourceServer // 开启资源服务
@EnableGlobalMethodSecurity(prePostEnabled = true) // 开启方法级别上的保护
public class ResourceServerConfigurer extends ResourceServerConfigurerAdapter {

    @Autowired
    TokenStore tokenStore;

    @Override
    public void configure(HttpSecurity http) throws Exception {

        http.authorizeRequests()
                .antMatchers("/user/login", "/user/register").permitAll()
                .anyRequest().authenticated();
    }

    @Override
    public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
        resources.tokenStore(tokenStore);
    }
}

JWT 类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
public class JWT {
    private String access_token;
    private String token_type;
    private String refresh_token;
    private int expires_in;
    private String scope;
    private String jti;

    public String getAccess_token() {
        return access_token;
    }

    public void setAccess_token(String access_token) {
        this.access_token = access_token;
    }

    public String getToken_type() {
        return token_type;
    }

    public void setToken_type(String token_type) {
        this.token_type = token_type;
    }

    public String getRefresh_token() {
        return refresh_token;
    }

    public void setRefresh_token(String refresh_token) {
        this.refresh_token = refresh_token;
    }

    public int getExpires_in() {
        return expires_in;
    }

    public void setExpires_in(int expires_in) {
        this.expires_in = expires_in;
    }

    public String getScope() {
        return scope;
    }

    public void setScope(String scope) {
        this.scope = scope;
    }

    public String getJti() {
        return jti;
    }

    public void setJti(String jti) {
        this.jti = jti;
    }

    @Override
    public String toString() {
        return "JWT{" +
                "access_token='" + access_token + '\'' +
                ", token_type='" + token_type + '\'' +
                ", refresh_token='" + refresh_token + '\'' +
                ", expires_in=" + expires_in +
                ", scope='" + scope + '\'' +
                ", jti='" + jti + '\'' +
                '}';
    }
}

Feign 客户端

1
2
3
4
5
6
7
@FeignClient("oauth2-server")
public interface AuthServiceClient {

    @PostMapping("/uaa/oauth/token")
    JWT getToken(@RequestHeader(value = "Authorization") String authorization, @RequestParam("grant_type") String type,
                 @RequestParam("username") String username, @RequestParam("password") String password);
}

同时需要在启动类添加注解：

1
@EnableFeignClients

DTO 及异常处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class UserLoginDTO {

    private JWT jwt;
    private User user;

    public JWT getJwt() {
        return jwt;
    }

    public void setJwt(JWT jwt) {
        this.jwt = jwt;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }
}
1
2
3
4
5
6
public class UserLoginException extends RuntimeException {

    public UserLoginException(String message){
        super(message);
    }
}
1
2
3
4
5
6
7
8
9
@ControllerAdvice // 表明该类是异常统一处理类
@ResponseBody
public class ExceptionHandle {

    @ExceptionHandler(UserLoginException.class)
    public ResponseEntity<String> handleException(Exception e){
        return new ResponseEntity(e.getMessage(), HttpStatus.OK);
    }
}

service & controller

添加登录方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Override
public UserLoginDTO login(String username, String password) {
    User user = userDao.findByUsername(username);
    if(null == user){
        throw new UserLoginException("error username");
    }
    if(!password.equals(user.getPassword())){
        throw new UserLoginException("erro password");
    }

    JWT jwt = authServiceClient.getToken("Basic ZXVyZWthLWNsaWVudDoxMjM0NTY="
            , "password", username, password); // ZXVyZWthLWNsaWVudDoxMjM0NTY= 为 eureka-client:123456 Base64 加密后的值
    if(null == jwt){
        throw new UserLoginException("error internal");
    }

    UserLoginDTO userLoginDTO = new UserLoginDTO();
    userLoginDTO.setJwt(jwt);
    userLoginDTO.setUser(user);

    return userLoginDTO;
}
1
2
3
4
5
@RequestMapping(value = "/login", method = RequestMethod.POST)
public UserLoginDTO login(@RequestParam("username") String username
        , @RequestParam("password") String password){
    return userService.login(username, password);
}

测试

  1. 启动 eureka-server
  2. 启动 oauth2-server
  3. 启动 config-server
  4. 启动 eureka-client

先取消授权：

1
DELETE FROM user_role WHERE user_id = 2;

使用 Postman 测试：

用户登录
- POST localhost:8011/user/login
Body
- username admin
- password 123 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
{
    "jwt": {
        "access_token": "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE1NjEyNjUyMzgsInVzZXJfbmFtZSI6ImFkbWluIiwianRpIjoiNTQxMDk3MDItNTU1Yy00NjA4LThkYzYtNzU3NWZjNGIwNGIyIiwiY2xpZW50X2lkIjoiZXVyZWthLWNsaWVudCIsInNjb3BlIjpbInNlcnZlciJdfQ.P6dtT76bFyQ6aF7-v6Vphi3ivLR0x4w739gwmBRGujaRpfDMjwQHCn5REyxEOAKdoxrVT__v73qcb78_8Ovb97L13ztnzdlPmLYzcAkQdMFz78yAjZIp2VtzxZ87Ecmk9f6-bIRlBxS9A24t0y4Tp1gkPITB1vxod0FewAHCsUJQ9WqLNeW9bxzZvy5DtlJlCCY7lOIjfDxlQdXygpwznZ4rIHv-O-eOr2aqcKMLZhdtW7hHsy2JccIUm1ZdpVQfUMD7XzWFAQoZYFLc0oXyVL0nFasOr-Ne1UR1iZYI4cS-ONVLMe78erVb-zRoyTAhEb7Pkyepkwm_Xv23U2CoeA",
        "token_type": "bearer",
        "refresh_token": "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE1NjM4NTM2MzgsInVzZXJfbmFtZSI6ImFkbWluIiwianRpIjoiODhjYTQ0NjktMTIyNi00ZTFkLTlhMDktZDZlMTdhOTMyYzAzIiwiY2xpZW50X2lkIjoiZXVyZWthLWNsaWVudCIsInNjb3BlIjpbInNlcnZlciJdLCJhdGkiOiI1NDEwOTcwMi01NTVjLTQ2MDgtOGRjNi03NTc1ZmM0YjA0YjIifQ.RdBDYKhZJz5DntxK_4np1B4phnalT37srjycUUmCHVZ0BB4lEWAIT5YLlY7ZaaVM2AAhbeb1WO1dhlmvtmlkd8W6lowbtMeyMYqrKcbn1tYavLwZDHKWSHGiUW1bXivngwhixCqLwK0AA8Oe-9-ohC-c6G7cRN4r6bWkc4WiadlErg6MS7N6VGdQj26SgPVmTqvVhpm5mnzGJyM66d-kxneHyRjPVli1DFyxuUl8oRCTTFuamybXmD_niWCA-isDgF7loJFV6hMjoow6-3uK9rLthMADIM4YqAp8T8eGsup_7hIICwT7qUhOdzBjwsuX8ond3iu09322LsPEoTTXlg",
        "expires_in": 3599,
        "scope": "server",
        "jti": "54109702-555c-4608-8dc6-7575fc4b04b2"
    },
    "user": {
        "id": 2,
        "username": "admin",
        "password": "123",
        "authorities": [],
        "enabled": true,
        "credentialsNonExpired": true,
        "accountNonExpired": true,
        "accountNonLocked": true
    }
}

访问不需要权限的接口
- GET localhost:8011/hi?name=Victor
Headers
- Authorization Bearer eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE1NjEyNjUyMzgsInVzZXJfbmFtZSI6ImFkbWluIiwianRpIjoiNTQxMDk3MDItNTU1Yy00NjA4LThkYzYtNzU3NWZjNGIwNGIyIiwiY2xpZW50X2lkIjoiZXVyZWthLWNsaWVudCIsInNjb3BlIjpbInNlcnZlciJdfQ.P6dtT76bFyQ6aF7-v6Vphi3ivLR0x4w739gwmBRGujaRpfDMjwQHCn5REyxEOAKdoxrVT__v73qcb78_8Ovb97L13ztnzdlPmLYzcAkQdMFz78yAjZIp2VtzxZ87Ecmk9f6-bIRlBxS9A24t0y4Tp1gkPITB1vxod0FewAHCsUJQ9WqLNeW9bxzZvy5DtlJlCCY7lOIjfDxlQdXygpwznZ4rIHv-O-eOr2aqcKMLZhdtW7hHsy2JccIUm1ZdpVQfUMD7XzWFAQoZYFLc0oXyVL0nFasOr-Ne1UR1iZYI4cS-ONVLMe78erVb-zRoyTAhEb7Pkyepkwm_Xv23U2CoeA 
1
Hello Victor, from port: 8011, version: 1.0.2

访问需要权限的接口
- GET localhost:8011/hello
Headers
- Authorization Bearer eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE1NjEyNjUyMzgsInVzZXJfbmFtZSI6ImFkbWluIiwianRpIjoiNTQxMDk3MDItNTU1Yy00NjA4LThkYzYtNzU3NWZjNGIwNGIyIiwiY2xpZW50X2lkIjoiZXVyZWthLWNsaWVudCIsInNjb3BlIjpbInNlcnZlciJdfQ.P6dtT76bFyQ6aF7-v6Vphi3ivLR0x4w739gwmBRGujaRpfDMjwQHCn5REyxEOAKdoxrVT__v73qcb78_8Ovb97L13ztnzdlPmLYzcAkQdMFz78yAjZIp2VtzxZ87Ecmk9f6-bIRlBxS9A24t0y4Tp1gkPITB1vxod0FewAHCsUJQ9WqLNeW9bxzZvy5DtlJlCCY7lOIjfDxlQdXygpwznZ4rIHv-O-eOr2aqcKMLZhdtW7hHsy2JccIUm1ZdpVQfUMD7XzWFAQoZYFLc0oXyVL0nFasOr-Ne1UR1iZYI4cS-ONVLMe78erVb-zRoyTAhEb7Pkyepkwm_Xv23U2CoeA 
1
2
3
4
{
    "error": "access_denied",
    "error_description": "不允许访问"
}

手动授权：

1
INSERT INTO user_role (user_id, role_id) VALUES (2, 2);

重新登录后再次访问接口

1
hello!

完整代码：GitHub

本人 C# 转 Java 的 newbie, 如有错误或不足欢迎指正，谢谢

展开全文 >>

Spring Cloud 学习 (九) Spring Security, OAuth2

Spring Security

Spring Security 是 Spring Resource 社区的一个安全组件。在安全方面，有两个主要的领域，一是“认证”，即你是谁；二是“授权”，即你拥有什么权限，Spring Security 的主要目标就是在这两个领域

Spring OAuth2

OAuth2 是一个标准的授权协议，允许不同的客户端通过认证和授权的形式来访问被其保护起来的资源

OAuth2 协议在 Spring Resource 中的实现为 Spring OAuth2，Spring OAuth2 分为：OAuth2 Provider 和 OAuth2 Client

OAuth2 Provider

OAuth2 Provider 负责公开被 OAuth2 保护起来的资源

OAuth2 Provider 需要配置代表用户的 OAuth2 客户端信息，被用户允许的客户端就可以访问被 OAuth2 保护的资源。OAuth2 Provider 通过管理和验证 OAuth2 令牌来控制客户端是否有权限访问被其保护的资源

另外，OAuth2 Provider 还必须为用户提供认证 API 接口。根据认证 API 接口，用户提供账号和密码等信息，来确认客户端是否可以被 OAuth2 Provider 授权。这样做的好处就是第三方客户端不需要获取用户的账号和密码，通过授权的方式就可以访问被 OAuth2 保护起来的资源

OAuth2 Provider 的角色被分为 Authorization Service (授权服务) 和 Resource Service (资源服务)，通常它们不在同一个服务中，可能一个 Authorization Service 对应多个 Resource Service

Spring OAuth2 需配合 Spring Security 一起使用，所有的请求由 Spring MVC 控制器处理,并经过一系列的 Spring Security 过滤器

在 Spring Security 过滤器链中有以下两个节点，这两个节点是向 Authorization Service 获取验证和授权的：

  1. 授权节点：默认为 /oauth/authorize
  2. 获取 Token 节点：默认为 /oauth/token

OAuth2 Client

OAuth2 Client (客户端) 用于访问被 OAuth2 保护起来的资源

新建 spring-security-oauth2-server

pom

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
<parent>
    <artifactId>spring-cloud-parent</artifactId>
    <groupId>com.karonda</groupId>
    <version>1.0.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>

<artifactId>spring-security-oauth2-server</artifactId>

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-oauth2</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-rest</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </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>

application.yml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
server:
  port: 8081

  servlet:
    context-path: /uaa # User Account and Authentication

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8001/eureka/

spring:
  application:
    name: oauth2-server

  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/spring-security-auth2?useSSL=false
    username: root
    password: root

    hikari:
      maximum-pool-size: 20
      minimum-idle: 5

  jpa:
    database-platform: org.hibernate.dialect.MySQL5InnoDBDialect
    show-sql: true
    hibernate:
      ddl-auto: update

  main:
    allow-bean-definition-overriding: true

数据表

创建用户和角色及中间表：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
DROP TABLE IF EXISTS role; 
CREATE TABLE role
(
    id bigint(20) NOT NULL AUTO_INCREMENT,
    name varchar(255) NOT NULL,
    PRIMARY KEY (id)
);


DROP TABLE IF EXISTS user; 
CREATE TABLE user 
(
    id bigint(20) NOT NULL AUTO_INCREMENT,
    password varchar(255) DEFAULT NULL, 
    username varchar(255) NOT NULL ,
    PRIMARY KEY (id ), 
    UNIQUE KEY (username)
);


DROP TABLE IF EXISTS user_role; 
CREATE TABLE user_role (
    user_id bigint(20) NOT NULL,
    role_id bigint(20) NOT NULL, 
    KEY (user_id), 
    KEY (role_id), 
    FOREIGN KEY (user_id) REFERENCES user (id),
    FOREIGN KEY (role_id) REFERENCES role (id)
);
````

OAuth2 Client 信息可以存储在数据库中，Spring OAuth2 已经设计好了数据表，且不可变，创建数据表的脚本：[schema.sql](https://github.com/spring-projects/spring-security-oauth/blob/master/spring-security-oauth2/src/test/resources/schema.sql) (如果使用 MySQL 需要将 LONGVARBINARY 替换为 BLOB)

初始化数据

INSERT INTO role (name) VALUES (‘ROLE_USER’);
INSERT INTO role (name) VALUES (‘ROLE_ADMIN’);

INSERT INTO user (username, password) VALUES (‘test’, ‘123’);

INSERT INTO user_role (user_id, role_id) VALUES (1, 1);

1
2
3

## Entity & Dao & Service

@Entity
public class Role implements GrantedAuthority {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false)
private String name;

public Long getId() {
    return id;
}

public void setId(Long id) {
    this.id = id;
}

@Override
public String getAuthority() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

@Override
public String toString(){
    return name;
}

}

1
2
3

Role 实现了 GrantedAuthority 接口

@Entity
public class User implements UserDetails, Serializable {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false, unique = true)
private String username;
@Column
private String password;
@ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
@JoinTable(name = "user_role", joinColumns = @JoinColumn(name = "user_id", referencedColumnName = "id"),
        inverseJoinColumns = @JoinColumn(name = "role_id", referencedColumnName = "id"))
private List<Role> authorities;

public User(){

}

public Long getId() {
    return id;
}

public void setId(Long id) {
    this.id = id;
}

@Override
public String getUsername() {
    return username;
}

public void setUsername(String username) {
    this.username = username;
}

@Override
public String getPassword() {
    return password;
}

public void setPassword(String password) {
    this.password = password;
}

@Override
public Collection<? extends GrantedAuthority> getAuthorities() {
    return authorities;
}

public void setAuthorities(List<Role> authorities) {
    this.authorities = authorities;
}

@Override
public boolean isAccountNonExpired(){
    return true;
}

@Override
public boolean isAccountNonLocked(){
    return true;
}

@Override
public boolean isCredentialsNonExpired(){
    return true;
}

@Override
public boolean isEnabled(){
    return true;
}

}

1
2
3

User 实现了 UserDetails 接口，该接口是 Spring Security 认证信息的核心接口

public interface UserDao extends JpaRepository<User, Long> {
User findByUsername(String username);
}

1

@Service
public class UserServiceDetail implements UserDetailsService {

@Autowired
private UserDao userDao;

@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
    return userDao.findByUsername(username);
}

}

1
2
3
4
5

UserServiceDetail 实现了 UserDetailsService 接口

## 启动类

@EnableEurekaClient
@SpringBootApplication
public class Oauth2ServerApp {

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

}

1
2
3

## Spring Security 配置

@Configuration
@EnableWebSecurity // 开启 Spring Security
@EnableGlobalMethodSecurity(prePostEnabled = true) // 开启方法级别上的保护
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

@Autowired
private UserServiceDetail userServiceDetail;

@Bean
public PasswordEncoder passwordEncoder() {
    return NoOpPasswordEncoder.getInstance();
}

@Override
protected void configure(HttpSecurity http) throws Exception {
    http.authorizeRequests()
            .anyRequest().authenticated() // 所有请求都需要安全验证
            .and()
            .csrf().disable();
}

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    auth.userDetailsService(userServiceDetail).passwordEncoder(passwordEncoder());
}

@Override
@Bean
public AuthenticationManager authenticationManagerBean() throws Exception {
    return super.authenticationManagerBean();
}

}

1
2
3
4
5
6
7

**Spring Security 5 使用 Spring Security 4 的配置会报 There is no PasswordEncoder mapped for the id "null" 异常，解决方法是使用 NoOpPasswordEncoder (临时解决方案，非最优方案)**

*--- 2020-04-24 更新开始 ---*

PasswordEncoder 可以使用自定义 Encoder：

@Bean
public PasswordEncoder passwordEncoder() {
return new MyPasswordEncoder();
}

1
2
3

MyPasswordEncoder 代码：

public class MyPasswordEncoder implements PasswordEncoder {

@Override
public String encode(CharSequence charSequence) {
    return PasswordUtil.getencryptPassword((String)charSequence);
}

@Override
public boolean matches(CharSequence charSequence, String s) {
    boolean result = PasswordUtil.matches(charSequence, s);
    return result;
}

}

1
2
3

PasswordUtil 代码：

public class PasswordUtil {

private static final BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();

public static String getencryptPassword(String password){
    return encoder.encode(password);
}

public static boolean matches(CharSequence rawPassword, String encodedPassword){
    return encoder.matches(rawPassword, encodedPassword);
}

}

1
2
3
4
5
6
7



*--- 2020-04-24 更新结束 ---*

## Authorization Server 配置

@Configuration
@EnableAuthorizationServer // 开启授权服务
@EnableResourceServer // 需要对外暴露获取和验证 Token 的接口，所以也是一个资源服务
public class OAuth2Config extends AuthorizationServerConfigurerAdapter{

@Autowired
private DataSource dataSource;

@Autowired
private AuthenticationManager authenticationManager;

@Autowired
private UserServiceDetail userServiceDetail;

@Override
// 配置客户端信息
public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
    clients.inMemory() // 将客户端的信息存储在内存中
            .withClient("browser") // 客户端 id, 需唯一
            .authorizedGrantTypes("refresh_token", "password") // 认证类型为 refresh_token, password
            .scopes("ui") // 客户端域
            .and()
            .withClient("eureka-client") // 另一个客户端
            .secret("123456")  // 客户端密码
            .authorizedGrantTypes("client_credentials", "refresh_token", "password")
            .scopes("server");
}

@Override
// 配置授权 token 的节点和 token 服务
public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
    endpoints.tokenStore(tokenStore()) // token 的存储方式
            .authenticationManager(authenticationManager) // 开启密码验证，来源于 WebSecurityConfigurerAdapter
            .userDetailsService(userServiceDetail); // 读取验证用户的信息
}

@Override
// 配置 token 节点的安全策略
public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
    security.tokenKeyAccess("permitAll()") // 获取 token 的策略
            .checkTokenAccess("isAuthenticated()");
}

@Bean
public TokenStore tokenStore() {

// return new InMemoryTokenStore();

    return new JdbcTokenStore(dataSource);
}

}

1
2
3

## RemoteTokenServices 接口

@RestController
@RequestMapping(“/users”)
public class UserController {

@RequestMapping(value = "/current", method = RequestMethod.GET)
public Principal getUser(Principal principal){
    return principal;
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

本文采用 RemoteTokenServices 这种方式对 Token 进行验证，如果其他资源服务需要验证 Token 则需要远程调用授权服务暴露的验证 Token 的 API 接口

## 测试

1. 启动 eureka-server
1. 启动 oauth2-server

使用 Postman 测试：

|  |  |  |
| ------ | ------ | ------ |
| - | POST | http://localhost:8081/uaa/oauth/token |
| Headers | | |
| - | Authorization | Basic ZXVyZWthLWNsaWVudDoxMjM0NTY= |
| Body | | |
| - | username | test |
| - | password | 123 |
| - | grant_type | password |


其中 Authorization 的值为 Basic clientId:secret (本文中为 eureka-client:123456) Base64 加密后的值

返回结果：

{
“access_token”: “5dc978ab-8c7e-4286-92f5-5655b8d15c98”,
“token_type”: “bearer”,
“refresh_token”: “7ef02b1c-6e8a-485f-adc9-18a48c2ae410”,
“expires_in”: 43199,
“scope”: “server”
}

1
2
3
4
5
6


# eureka-client

## 添加依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-oauth2</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</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>

1
2
3

## application.xml 添加

security:
oauth2:
resource:
user-info-uri: http://localhost:8081/uaa/users/current
client:
client-id: eureka-client
client-secret: 123456
access-token-uri: http://localhost:8081/uaa/oauth/token
grant-type: client_credentials, password
scope: server

1
2
3
4
5

数据库配置同 oauth2-server 未列出

## 配置 Resource Server

@Configuration
@EnableResourceServer // 开启资源服务
@EnableGlobalMethodSecurity(prePostEnabled = true) // 开启方法级别上的保护
public class ResourceServerConfigurer extends ResourceServerConfigurerAdapter {

@Override
public void configure(HttpSecurity http) throws Exception {

    http.authorizeRequests()
            .antMatchers("/user/register").permitAll()
            .anyRequest().authenticated();
}

}

1
2
3

## 配置 OAuth2 Client

@EnableOAuth2Client // 开启 OAuth2 Client
@EnableConfigurationProperties
@Configuration
public class OAuth2ClientConfig {

@Bean
@ConfigurationProperties(prefix = "security.oauth2.client")
// 配置受保护的资源信息
public ClientCredentialsResourceDetails clientCredentialsResourceDetails(){
    return new ClientCredentialsResourceDetails();
}

@Bean
// 过滤器，存储当前请求和上下文
public RequestInterceptor oAuth2FeignRequestInterceptor(){
    return new OAuth2FeignRequestInterceptor(new DefaultOAuth2ClientContext(), clientCredentialsResourceDetails());
}

@Bean
public OAuth2RestTemplate clientCredentialsRestTemplate (){
    return new OAuth2RestTemplate(clientCredentialsResourceDetails());
}

}

1
2
3
4
5
6
7

## Entity & Dao & Service

与 oauth2-server 类似，具体见代码

## Controller

@RestController
@RequestMapping(“/user”)
public class UserController {

@Autowired
private UserService userService;

@RequestMapping(value = "/register", method = RequestMethod.POST)
public User createUser(@RequestParam("username") String username
        , @RequestParam("password") String password){
    return userService.create(username, password);
}

}

1

@RestController
public class HiController {

@Value("${server.port}")
int port;

@Value("${version}")
String version;

@GetMapping("/hi")
public String home(@RequestParam String name){
    return "Hello " + name + ", from port: " + port + ", version: " + version;
}

@PreAuthorize("hasAuthority('ROLE_ADMIN')") // 需要权限
@RequestMapping("/hello")
public String hello(){
    return "hello!";
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22


## 测试

1. 启动 eureka-server
1. 启动 oauth2-server
1. 启动 config-server
1. 启动 eureka-client

使用 Postman 测试：

### 注册用户

|  |  |  |
| ------ | ------ | ------ |
| - | POST | localhost:8011/user/register |
| Body | | |
| - | username | admin |
| - | password | 123 |

返回结果：

{
“id”: 2,
“username”: “admin”,
“password”: “123”,
“authorities”: null,
“enabled”: true,
“accountNonExpired”: true,
“credentialsNonExpired”: true,
“accountNonLocked”: true
}

1
2
3
4
5
6
7
8
9
10
11
12
13

### 请求 token

|  |  |  |
| ------ | ------ | ------ |
| - | POST | http://localhost:8081/uaa/oauth/token |
| Headers | | |
| - | Authorization | Basic ZXVyZWthLWNsaWVudDoxMjM0NTY= |
| Body | | |
| - | username | admin |
| - | password | 123 |
| - | grant_type | password |

{
“access_token”: “dc4959fb-9ced-430e-9a78-5e9609c3baac”,
“token_type”: “bearer”,
“refresh_token”: “06cdcf55-fe6a-4367-94e1-051c2da86e37”,
“expires_in”: 43199,
“scope”: “server”
}

1
2
3
4
5
6
7
8
9

### 访问不需要权限的接口

|  |  |  |
| ------ | ------ | ------ |
| - | GET | localhost:8011/hi?name=Victor |
| Headers | | |
| - | Authorization | Bearer dc4959fb-9ced-430e-9a78-5e9609c3baac |

Hello Victor, from port: 8011, version: 1.0.2

1
2
3
4
5
6
7
8
9

### 访问需要权限的接口

|  |  |  |
| ------ | ------ | ------ | 
| - | GET | localhost:8011/hello |
| Headers | | |
| - | Authorization | Bearer dc4959fb-9ced-430e-9a78-5e9609c3baac |

{
“error”: “access_denied”,
“error_description”: “不允许访问”
}

1
2
3

手动授权：


INSERT INTO user_role (user_id, role_id) VALUES (2, 2);
1
2
3

重新获取 token 后再次访问接口


hello!






完整代码：[GitHub](https://github.com/VictorBu/code-snippet/tree/master/java/spring-cloud-parent)

**本人 C# 转 Java 的 newbie, 如有错误或不足欢迎指正，谢谢**

展开全文 >>

Spring Cloud 学习 (八) Spring Boot Admin

Spring Boot Admin 用于管理和监控一个或者多个 Spring Boot 程序

新建 spring-boot-admin-server

pom

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<parent>
    <artifactId>spring-cloud-parent</artifactId>
    <groupId>com.karonda</groupId>
    <version>1.0.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>

<artifactId>spring-boot-admin-server</artifactId>

<dependencies>
    <dependency>
        <groupId>de.codecentric</groupId>
        <artifactId>spring-boot-admin-starter-server</artifactId>
        <version>RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
</dependencies>

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

spring-boot-admin-starter-server 需要指定版本号

application.yml

1
2
3
4
5
6
7
8
9
10
11
12
server:
  port: 8071


eureka:
  client:
    service-url:
      defaultZone: http://localhost:8001/eureka/

spring:
  application:
    name: admin-server

启动类

1
2
3
4
5
6
7
8
@EnableAdminServer // 开启 Admin Server
@EnableEurekaClient
@SpringBootApplication
public class AdminServerApp {
    public static void main(String[] args){
        SpringApplication.run(AdminServerApp.class, args);
    }
}

eureka-client

添加依赖

1
2
3
4
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

注册 Spring Boot Admin (SBA) 客户端有两种方式：一种是通过引入 SBA Client (spring-boot-admin-starter-client)；另一种是基于 Spring Cloud Discovery, 不需要添加依赖

application.xml 添加

1
2
3
4
5
6
7
8
management:
  endpoints:
    web:
      exposure:
        include: "*"
  endpoint:
    health:
      show-details: ALWAYS

测试

  1. 启动 eureka-server
  2. 启动 config-server
  3. 启动 eureka-client
  4. 启动 admin-server

访问 http://localhost:8071

完整代码：GitHub

本人 C# 转 Java 的 newbie, 如有错误或不足欢迎指正，谢谢

展开全文 >>

Spring Cloud 学习 (七) Spring Cloud Sleuth

微服务架构是一个分布式架构，微服务系统按业务划分服务单元，一个微服务系统往往有很多个服务单元。由于服务单元数量众多，业务的复杂性较高，如果出现了错误和异常，很难去定位。主要体现在一个请求可能需要调用很多个服务，而内部服务的调用复杂性决定了问题难以定位。所以在微服务架构中，必须实现分布式链路追踪，去跟进一个请求到底有哪些服务参与，参与的顺序又是怎样的，从而达到每个请求的步骤清晰可见，出了问题能够快速定位的目的

常见的链路追踪组件有 Google 的 Dapper、Twitter 的 Zipkin，以及阿里的 Eagleeye (鹰眼)

概念

  1. Span: 基本工作单元，发送一个远程调度任务就会产生一个 Span。包含了摘要、时间戳事件、 Span 的 ID 以及进程 ID
  2. Trace: 由一系列 Span 组成的，呈树状结构。请求一个微服务系统的 API 接口，这个 API 接口需要调用多个微服务单元，调用每个微服务单元都会产生一个新的 Span，所有由这个请求产生的 Span 组成了这个 Trace
  3. Annotation: 用于记录一个事件，一些核心注解用于定义一个请求的开始和结束，这些注解如下：
    1. cs-Client Sent: 客户端发送一个请求，这个注解描述了 Span 的开始
    2. sr-Server Received: 服务端获得请求并准备开始处理它，用 sr 减去 cs 时间戳，便可得到网络传输的时间
    3. ss-Server Sent: 服务端发送响应，该注解表明请求处理的完成 (当请求返回客户端)，用 ss 的时间戳减去 sr 时间戳，便可以得到服务器请求的时间
    4. er-Client Received: 客户端接收响应，此时 Span 结束，用 er 的时间戳减去 cs 时间戳，便可以得到整个请求所消耗的时间

Zipkin Server

下载 Zipkin Server

启动 Zipkin Server：

1
java -jar zipkin-server-2.12.9-exec.jar

Zipkin Server 默认端口为 9411

更详细关于 Zipkin 参考：https://zipkin.io/pages/quickstart.html

eureka-client

添加依赖

1
2
3
4
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-zipkin</artifactId>
</dependency>

application.yml 添加

1
2
3
4
5
6
7
spring:

  zipkin:
    base-url: http://localhost:9411 # Zipkin Server 地址
  sleuth:
    sampler:
      probability: 1.0 # 以 100% 的概率将链路的数据上传给 Zipkin Server

zuul-client

步骤同 eureka-client

测试

  1. 启动 eureka-server
  2. 启动 config-server
  3. 启动 eureka-client
  4. 启动 zuul-client

访问 http://localhost:8051/hiapi/hi?name=victor&token=xx

访问 http://localhost:9411/zipkin 点击 [查找] 按钮即可看到链路信息

完整代码：GitHub

本人 C# 转 Java 的 newbie, 如有错误或不足欢迎指正，谢谢

展开全文 >>

Spring Cloud 学习 (六) Spring Cloud Config

在实际开发过程中，每个服务都有大量的配置文件，例如数据库的配置、日志输出级别的配置等，而往往这些配置在不同的环境中也是不一样的。随着服务数量的增加，配置文件的管理也是一件非常复杂的事

在微服务架构中，需要有统一管理配置文件的组件，例如 Spring Cloud 的 Spring Cloud Config、阿里的 Diamond、百度的 Disconf、携程的 Apollo 等

新建 spring-cloud-config-server

从本地读取配置

pom

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<parent>
    <artifactId>spring-cloud-parent</artifactId>
    <groupId>com.karonda</groupId>
    <version>1.0.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>

<artifactId>spring-cloud-config-server</artifactId>

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-config-server</artifactId>
    </dependency>
</dependencies>

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

application.yml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
server:
  port: 8061

spring:
  application:
    name: config-server

  profiles:
    active: native # 从本地读取配置

  cloud:
    config:
      server:
        native:
          search-locations: classpath:/shared # 本地配置路径

新建配置文件 shared/eureka-client-dev.yml

1
version: 1.0.0

启动类

1
2
3
4
5
6
7
@EnableConfigServer // 开启 Config Server
@SpringBootApplication
public class ConfigServerApp {
    public static void main(String[] args){
        SpringApplication.run(ConfigServerApp.class, args);
    }
}

测试

启动 config-server

访问 http://localhost:8061/eureka-client/dev 可以看到配置

在客户端使用

在 eureka-client 测试

添加依赖

1
2
3
4
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>

添加配置 bootstrap.yml

1
2
3
4
5
6
7
8
9
10
11
spring:
  application:
    name: eureka-client

  cloud:
    config:
      uri: http://localhost:8061
      fail-fast: true

  profiles:
    active: dev

bootstrap.yml 优先于 application.yml

修改测试代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@RestController
public class HiController {

    @Value("${server.port}")
    int port;

    @Value("${version}")
    String version;

    @GetMapping("/hi")
    public String home(@RequestParam String name){
        return "Hello " + name + ", from port: " + port + ", version: " + version;
    }
}

测试

  1. 启动 config-server
  2. 启动 eureka-server
  3. 启动 eureka-client

访问 http://localhost:8011/hi?name=Victor

从远程 Git 仓库读取配置

修改 application.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
server:
  port: 8061

spring:
  application:
    name: config-server

#  profiles:
#    active: native # 从本地读取配置

  cloud:
    config:
      server:
#        native:
#          search-locations: classpath:/shared # 本地配置路径
        git:
          uri: https://github.com/VictorBu/spring-cloud-config-demo
          search-paths: repo # 搜索的文件夹地址
#          username: # 如果是私有仓库须配置
#          password: # 如果是私有仓库须配置
      label: master # git 仓库分支名

测试

参考上节

完整代码：GitHub

本人 C# 转 Java 的 newbie, 如有错误或不足欢迎指正，谢谢

展开全文 >>

Spring Cloud 学习 (五) Zuul

Zuul 作为路由网关组件，在微服务架构中有着非常重要的作用，主要体现在以下 6 个方面：

  1. Zuul, Ribbon 以及 Eureka 相结合，可以实现智能路由和负载均衡的功能，Zuul 能够将请求流量按某种策略分发到集群状态的多个服务实例
  2. 网关将所有服务的 API 接口统一聚合，并统一对外暴露。外界系统调用 API 接口时，都是由网关对外暴露的 API 接口，外界系统不需要知道微服务系统中各服务相互调用的复杂性。微服务系统也保护了其内部微服务单元的 API 接口 ， 防止其被外界直 接调用，导致服务的敏感信息对外暴露
  3. 网关服务可以做用户身份认证和权限认证，防止非法请求操作 API 接口，对服务器起到保护作用
  4. 网关可以实现监控功能，实时日志输出，对请求进行记录
  5. 网关可以用来实现流量监控，在高流量的情况下，对服务进行降级
  6. API 接口从内部服务分离出来，方便做测试

Zuul 的核心是一系列过滤器，可以在 Http 请求的发起和响应返回期间执行一系列的过滤器：

  1. PRE 过滤器：在请求路由到具体的服务之前执行，这种类型的过滤器可以做安全验证，例如身份验证、 参数验证等
  2. ROUTING 过滤器：用于将请求路由到具体的微服务实例。在默认情况下，它使用 Http Client 进行网络请求
  3. POST 过滤器：在请求己被路由到微服务后执行。 一般情况下，用作收集统计 信息、指标，以及将响应传输到客户端
  4. ERROR 过滤器：在其他过滤器发生错误时执行

Zuul 采取了动态读取、编译和运行这些过滤器。过滤器之间不能直接相互通信，而是通过 RequestContext 对象来共享数据，每个请求都会创建一个 RequestContext 对象。Zuul 过滤器具有以下关键特性：

  1. Type (类型): Zuul 过滤器的类型，这个类型决定了过滤器在请求的哪个阶段起作用，例如 Pre、Post 阶段等
  2. Execution Order (执行顺序): 规定了过滤器的执行顺序，Order 的值越小越先执行
  3. Criteria (标准): Filter 执行所需的条件
  4. Action (行动): 如果符合执行条件，则执行 Action (即逻辑代码)

使用 Zuul

新建 spring-cloud-eureka-zuul-client

pom

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
<parent>
    <artifactId>spring-cloud-parent</artifactId>
    <groupId>com.karonda</groupId>
    <version>1.0.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>

<artifactId>spring-cloud-eureka-zuul-client</artifactId>


<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-rest</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
    </dependency>
</dependencies>

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

application.yml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
server:
  port: 8051


eureka:
  client:
    service-url:
      defaultZone: http://localhost:8001/eureka/

spring:
  application:
    name: zuul-client

zuul:
  routes:
    hiapi:
      path: /hiapi/**
      serviceId: eureka-client
    ribbonapi:
      path: /ribbonapi/**
      serviceId: ribbon-client
    feignapi:
      path: /feignapi/**
      serviceId: feign-client

启动类

1
2
3
4
5
6
7
@EnableZuulProxy // 开启 Zuul
@SpringBootApplication
public class EurekaZuulClientApp {
    public static void main(String[] args){
        SpringApplication.run(EurekaZuulClientApp.class, args);
    }
}

测试

  1. 启动 eureka-server
  2. 启动 eureka-client (两个实例：一个 8011 端口，一个 8012 端口)
  3. 启动 eureka-ribbon-client
  4. 启动 eureka-feign-client
  5. 启动 eureka-zuul-client

多次访问 http://localhost:8031/hiapi/hi?name=victor 可以看到 8011 和 8012 端口交替出现 (Zuul 默认 与 Ribbon 结合实现了负载均衡)

多次访问 http://localhost:8031/ribbonapi/hi?name=victor 可以看到 8011 和 8012 端口交替出现

多次访问 http://localhost:8031/feignapi/hi?name=victor 可以看到 8011 和 8012 端口交替出现

在 Zuul 上配置熔断器

实现 FallbackProvider 接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
@Component
public class MyFallbackProvider implements FallbackProvider {

    @Override
    public String getRoute() {
        return "eureka-client"; // 如果所有的路由服务都加熔断功能，返回 "*"
    }

    @Override
    public ClientHttpResponse fallbackResponse(String route, Throwable cause) {
        return new ClientHttpResponse() {
            @Override
            public HttpStatus getStatusCode() throws IOException {
                return HttpStatus.OK;
            }

            @Override
            public int getRawStatusCode() throws IOException {
                return 200;
            }

            @Override
            public String getStatusText() throws IOException {
                return "OK";
            }

            @Override
            public void close() {

            }

            @Override
            public InputStream getBody() throws IOException {
                return new ByteArrayInputStream("error, fallback".getBytes());
            }

            @Override
            public HttpHeaders getHeaders() {
                HttpHeaders headers = new HttpHeaders();
                headers.setContentType(MediaType.APPLICATION_JSON);
                return headers;
            }
        };
    }
}

测试

  1. 关闭所有的 eureka-client
  2. 重启 eureka-zuul-client

在 Zuul 中使用过滤器

继承 ZuulFilter

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
@Component
public class MyFilter extends ZuulFilter {

    private static Logger logger = LoggerFactory.getLogger(MyFilter.class);

    @Override
    public String filterType() {
        return PRE_TYPE;
    }

    @Override
    public int filterOrder() {
        return 0;
    }

    @Override
    public boolean shouldFilter() {
        return true;
    }

    @Override
    public Object run() throws ZuulException {

        RequestContext ctx = RequestContext.getCurrentContext();
        HttpServletRequest request = ctx.getRequest();
        Object accessToken = request.getParameter("token");

        if(accessToken == null){
            logger.warn("token is empty");
            ctx.setSendZuulResponse(false);
            ctx.setResponseStatusCode(401);

            try {
                ctx.getResponse().getWriter().write("token is empty");
            } catch (IOException e) {
                return null;
            }
        }

        logger.info("ok");

        return null;
    }
}

测试

  1. 重启 eureka-zuul-client

访问 http://localhost:8051/hiapi/hi?name=victor

访问 http://localhost:8051/hiapi/hi?name=victor&token=xx

完整代码：GitHub

本人 C# 转 Java 的 newbie, 如有错误或不足欢迎指正，谢谢

展开全文 >>

Spring Cloud 学习 (四) Hystrix & Hystrix Dashboard & Turbine

在复杂的分布式系统中，可能有几十个服务相互依赖，这些服务由于某些原因，例如机房的不可靠性、网络服务商的不可靠性等，导致某个服务不可用 。 如果系统不隔离该不可用的服务，可能会导致整个系统不可用。Hystrix 提供了熔断器功能，能够阻止分布式系统中出现联动故障。Hystrix 是通过隔离服务的访问点阻止联动故障的，并提供了故障的解决方案，从而提高了整个分布式系统的弹性。

使用 Hystrix

在 Ribbon 使用 Hystrix

添加依赖包

1
2
3
4
<dependency>
    <groupId>com.netflix.hystrix</groupId>
    <artifactId>hystrix-javanica</artifactId>
</dependency>

修改启动类

1
2
3
4
5
6
7
8
@EnableHystrix // 启用 Hystrix 熔断器
@EnableEurekaClient
@SpringBootApplication
public class EurekaRibbonClientApp {
    public static void main(String[] args){
        SpringApplication.run(EurekaRibbonClientApp.class, args);
    }
}

修改 Service

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Service
public class RibbonService {
    @Autowired
    RestTemplate restTemplate;

    @HystrixCommand(fallbackMethod = "hiError") // 启用 Hystrix 熔断器
    public String hi(String name){
        return restTemplate.getForObject("http://eureka-client/hi?name=" + name, String.class);
    }

    public String hiError(String name){
        return "error! sorry, " + name;
    }
}

测试

  1. 启动 eureka-server
  2. 启动 eureka-ribbon-client

访问 http://localhost:8021/hi?name=victor 可以看到返回的是 hiError 方法执行的结果

在 Feign 使用 Hystrix

application.yml 添加

1
2
3
feign:
  hystrix:
    enabled: true

添加熔断处理类

1
2
3
4
5
6
7
8
@Component
public class HiHystrix implements EurekaClientFeign {

    @Override
    public String sayHi(String name) {
        return "error! sorry, " + name;
    }
}

修改 FeignClient

1
2
3
4
5
6
7
@FeignClient(value = "eureka-client", configuration = FeignConfig.class
        , fallback = HiHystrix.class)
public interface EurekaClientFeign {

    @GetMapping("/hi")
    String sayHi(@RequestParam(value = "name") String name);
}

测试

  1. 启动 eureka-server
  2. 启动 eureka-feign-client

访问 http://localhost:8031/hi?name=victor 可以看到返回的是 hiError 方法执行的结果

使用 Hystrix Dashboard 监控熔断器状态

在 Ribbon 使用 Hystrix Dashboard

添加依赖包

1
2
3
4
5
6
7
8
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
</dependency>

修改启动类

1
2
3
4
5
6
7
8
9
@EnableHystrix // 启用 Hystrix 熔断器
@EnableHystrixDashboard // 启用 Hystrix Dashboard
@EnableEurekaClient
@SpringBootApplication
public class EurekaRibbonClientApp {
    public static void main(String[] args){
        SpringApplication.run(EurekaRibbonClientApp.class, args);
    }
}

application.yml 添加

1
2
3
4
5
management:
  endpoints:
    web:
      exposure:
        include: "*"

测试

  1. 启动 eureka-server
  2. 启动 eureka-ribbon-client

先访问 http://localhost:8021/hi?name=victor，然后访问 http://localhost:8021/actuator/hystrix.stream 浏览器上会显示熔断器的数据指标

访问 http://localhost:8021/hystrix，然后在界面输入 http://localhost:8021/actuator/hystrix.stream 点击 [Monitor Stream] 按钮可以看到熔断器的各种数据指标

在 Feign 使用 Hystrix Dashboard

添加依赖包

1
2
3
4
5
6
7
8
9
10
11
12
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
</dependency>

与 Ribbon 相比需要添加 spring-cloud-starter-netflix-hystrix 依赖

修改启动类

1
2
3
4
5
6
7
8
9
10
@EnableFeignClients // 开启 Feign Client
@EnableHystrixDashboard // 启用 Hystrix Dashboard
@EnableCircuitBreaker // 启用 Hystrix 熔断器
@EnableEurekaClient
@SpringBootApplication
public class EurekaFeignClientApp {
    public static void main(String[] args){
        SpringApplication.run(EurekaFeignClientApp.class, args);
    }
}

与 Ribbon 相比需要添加 @EnableCircuitBreaker 注解

application.yml 添加

1
2
3
4
5
management:
  endpoints:
    web:
      exposure:
        include: "*"

测试

  1. 启动 eureka-server
  2. 启动 eureka-feign-client

先访问 http://localhost:8031/hi?name=victor，然后访问 http://localhost:8031/actuator/hystrix.stream 浏览器上会显示熔断器的数据指标

访问 http://localhost:8031/hystrix，然后在界面输入 http://localhost:8031/actuator/hystrix.stream 点击 [Monitor Stream] 按钮可以看到熔断器的各种数据指标

使用 Turbine 聚合监控

新建 spring-cloud-eureka-turbine-client Module

pom

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
<parent>
    <artifactId>spring-cloud-parent</artifactId>
    <groupId>com.karonda</groupId>
    <version>1.0.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>

<artifactId>spring-cloud-eureka-turbine-client</artifactId>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-turbine</artifactId>
    </dependency>
</dependencies>

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

application.yml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
server:
  port: 8041


eureka:
  client:
    service-url:
      defaultZone: http://localhost:8001/eureka/

spring:
  application:
    name: turbine-client
turbine:
  aggregator:
    cluster-config: default
  app-config: ribbon-client, feign-client
  cluster-name-expression: new String("default")

启动类

1
2
3
4
5
6
7
8
@SpringBootApplication
@EnableHystrixDashboard // 启用 Hystrix Dashboard
@EnableTurbine // 启用 Hystrix Turbine
public class EurekaTurbineClientApp {
    public static void main(String[] args){
        SpringApplication.run(EurekaTurbineClientApp.class, args);
    }
}

测试

  1. 启动 eureka-server
  2. 启动 eureka-ribbon-client
  3. 启动 eureka-feign-client
  4. 启动 eureka-turbine-client
  5. 访问 http://localhost:8021/hi?name=victor
  6. 访问 http://localhost:8031/hi?name=victor

访问 http://localhost:8021/hystrix 或 http://localhost:8031/hystrix 然后在界面输入 http://localhost:8041/turbine.stream 点击 [Monitor Stream] 按钮可以看到 eureka-ribbon-client 和 eureka-feign-client 熔断器的各种数据指标

完整代码：GitHub

本人 C# 转 Java 的 newbie, 如有错误或不足欢迎指正，谢谢

展开全文 >>

Spring Cloud 学习 (三) Feign

新建 spring-cloud-eureka-feign-client Module

pom

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
<parent>
    <artifactId>spring-cloud-parent</artifactId>
    <groupId>com.karonda</groupId>
    <version>1.0.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>

<artifactId>spring-cloud-eureka-feign-client</artifactId>

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

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

application.yml

1
2
3
4
5
6
7
8
9
10
11
12
server:
  port: 8031


eureka:
  client:
    service-url:
      defaultZone: http://localhost:8001/eureka/

spring:
  application:
    name: feign-client

启动类

1
2
3
4
5
6
7
8
@EnableFeignClients // 开启 Feign Client
@EnableEurekaClient
@SpringBootApplication
public class EurekaFeignClientApp {
    public static void main(String[] args){
        SpringApplication.run(EurekaFeignClientApp.class, args);
    }
}

FeignClient

1
2
3
4
5
6
@FeignClient("eureka-client")
public interface EurekaClientFeign {

    @GetMapping("/hi")
    String sayHi(@RequestParam(value = "name") String name);
}

Controller

1
2
3
4
5
6
7
8
9
10
11
@RestController
public class FeignController {

    @Autowired
    EurekaClientFeign eurekaClientFeign;

    @GetMapping("/hi")
    public String sayHi(@RequestParam String name){
        return eurekaClientFeign.sayHi(name);
    }
}

测试

  1. 启动 eureka-server
  2. 启动 eureka-client (两个实例：一个 8011 端口，一个 8012 端口)
  3. 启动 eureka-feign-client

多次访问 http://localhost:8031/hi?name=victor 可以看到 8011 和 8012 端口交替出现

添加失败重试

添加配置

1
2
3
4
5
6
7
8
@Configuration
public class FeignConfig {

    @Bean
    public Retryer feignRetryer(){
        return new Retryer.Default(100, SECONDS.toMillis(1), 5);
    }
}

修改 FeignClient

1
2
3
4
5
6
@FeignClient(value = "eureka-client", configuration = FeignConfig.class)
public interface EurekaClientFeign {

    @GetMapping("/hi")
    String sayHi(@RequestParam(value = "name") String name);
}

使用 HttpClient 或 OkHttp

在 Feign 中，Client 是一个非常重要的组件，Feign 最终发送 Request 请求以及接收 Response 响应都是由 Client 组件完成的。Client 在 Feign 源码中是一个接口，在默认的情况下， Client 的实现类是 Client.Default, Client.Default 是由 HttpURLConnnection 来实现网络请求的。Client 还支持 HttpClient 和 OkhHttp 来进行网络请求

直接添加 HttpClient 或 OkhHttp 依赖包，Feign 会自动使用对应的网络请求框架

完整代码：GitHub

本人 C# 转 Java 的 newbie, 如有错误或不足欢迎指正，谢谢

展开全文 >>

Spring Cloud 学习 (二) Ribbon

负载均衡是指将负载分摊到多个执行单元上，常见的负载均衡有两种方式：一种是独立进程单元，通过负载均衡策略，将请求转发到不同的执行单元上，例如 Ngnix；另一种是将负载均衡逻辑以代码的形式封装到服务消费者的客户端上，服务消费者客户端维护了一份服务提供者的信息列表，有了信息列表，通过负载均衡策略将请求分摊给多个服务提供者，从而达到负载均衡的目的，例如 Ribbon

新建 spring-cloud-eureka-ribbon-client Module

pom

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
<parent>
    <artifactId>spring-cloud-parent</artifactId>
    <groupId>com.karonda</groupId>
    <version>1.0.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>

<artifactId>spring-cloud-eureka-ribbon-client</artifactId>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-rest</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
    </dependency>
</dependencies>

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

application.yml

1
2
3
4
5
6
7
8
9
10
11
12
server:
  port: 8021


eureka:
  client:
    service-url:
      defaultZone: http://localhost:8001/eureka/

spring:
  application:
    name: ribbon-client

启动类

1
2
3
4
5
6
7
@EnableEurekaClient
@SpringBootApplication
public class EurekaRibbonClientApp {
    public static void main(String[] args){
        SpringApplication.run(EurekaRibbonClientApp.class, args);
    }
}

RestTemplate

1
2
3
4
5
6
7
8
@Configuration
public class RibbonConfig {
    @Bean
    @LoadBalanced // 开启负载均衡功能
    RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

Service

1
2
3
4
5
6
7
8
9
@Service
public class RibbonService {
    @Autowired
    RestTemplate restTemplate;

    public String hi(String name){
        return restTemplate.getForObject("http://eureka-client/hi?name=" + name, String.class);
    }
}

Controller

1
2
3
4
5
6
7
8
9
10
@RestController
public class RibbonController {
    @Autowired
    RibbonService ribbonService;

    @GetMapping("/hi")
    public String hi(@RequestParam String name){
        return ribbonService.hi(name);
    }
}

测试

  1. 启动 eureka-server
  2. 启动 eureka-client (两个实例：一个 8011 端口，一个 8012 端口)
  3. 启动 eureka-ribbon-client

多次访问 http://localhost:8021/hi?name=victor 可以看到 8011 和 8012 端口交替出现

完整代码：GitHub

本人 C# 转 Java 的 newbie, 如有错误或不足欢迎指正，谢谢

展开全文 >>

Spring Cloud 学习 (一) Eureka

微服务的功能主要有以下几个方面：

  • 服务的注册和发现
  • 服务的负载均衡
  • 服务的容错
  • 服务网关
  • 服务配置的统一管理
  • 链路追踪
  • 实时日志

服务注册是指向服务注册中心注册一个服务实例，服务提供者将自己的服务信息 (如服务名、IP 地址等) 告知服务注册中心。服务发现是指当服务消费者需要消费另外一个服务时，服务注册中心能够告知服务消费者它所要消费服务的实例信息(如服务名、IP 地址等)。通常情况下一个服务既是服务提供者，也是服务消费者。服务消费者一般使用 HTTP 协议或者消息组件这种轻量级的通信机制来进行服务消费。服务注册中心会提供服务的健康检查方案，检查被注册的服务是否可用。通常一个服务实例注册后，会定时向服务注册中心提供 “心跳”，以表明自己还处于可用的状态。当一个服务实例停止向服务注册中心提供心跳一段时间后，服务注册中心会认为该服务实例不可用，会将该服务实例从服务注册列表中剔 除。如果这个被剔除掉的服务实例过一段时间后继续向注册中心提供心跳，那么服务注册中心会将该服务实例重新加入服务注册中心的列表中。

Eureka 是一个用于服务注册和发现的组件，分为 Server (服务注册中心) 和 Client (服务提供者、服务消费者)。与 Eureka 类似得组件有 Consul 和 ZooKeeper。

Eureka 是 Spring Cloud 首选推荐的服务注册与发现组件，可以与 Spring Cloud 其他组件可以无缝对接。

Eureka Server

新建一个多模块项目 (可参考：使用 IDEA 创建多模块项目)，添加 spring-cloud-eureka-server 模块

其中父模块 pom：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
<modelVersion>4.0.0</modelVersion>
<packaging>pom</packaging>
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.4.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.karonda</groupId>
<artifactId>spring-cloud-parent</artifactId>
<version>1.0.0</version>
<name>spring-cloud-parent</name>
<description>spring cloud parent project</description>

<properties>
    <java.version>1.8</java.version>
    <spring-cloud.version>Greenwich.SR1</spring-cloud.version>
</properties>

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

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</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>
    </plugins>
</build>

pom：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<parent>
    <artifactId>spring-cloud-parent</artifactId>
    <groupId>com.karonda</groupId>
    <version>1.0.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>

<artifactId>spring-cloud-eureka-server</artifactId>

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

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

application.yml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
server:
  port: 8001

eureka:
  instance:
    hostname: localhost
  client:
    register-with-eureka: false # 默认情况下 Eureka Server 会向自己注册，设为 false 防止自己注册自己
    fetch-registry: false # 默认情况下 Eureka Server 会向自己注册，设为 false 防止自己注册自己
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

spring:
  application:
    name: eureka-server

启动类

1
2
3
4
5
6
7
@EnableEurekaServer // 开启 Eureka Server
@SpringBootApplication
public class EurekaServerApp {
    public static void main(String[] args){
        SpringApplication.run(EurekaServerApp.class, args);
    }
}

Eureka Client

pom

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<parent>
    <artifactId>spring-cloud-parent</artifactId>
    <groupId>com.karonda</groupId>
    <version>1.0.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>

<artifactId>spring-cloud-eureka-client</artifactId>


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

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

application.yml

1
2
3
4
5
6
7
8
9
10
11
12
server:
  port: 8011


eureka:
  client:
    service-url:
      defaultZone: http://localhost:8001/eureka/

spring:
  application:
    name: eureka-client

启动类

1
2
3
4
5
6
7
@EnableEurekaClient // 开启 Eureka Client
@SpringBootApplication
public class EurekaClientApp {
    public static void main(String[] args){
        SpringApplication.run(EurekaClientApp.class, args);
    }
}

测试代码

1
2
3
4
5
6
7
8
9
10
11
@RestController
public class HiController {

    @Value("${server.port}")
    int port;

    @GetMapping("/hi")
    public String home(@RequestParam String name){
        return "Hello " + name + ", from port: " + port;
    }
}

测试

分别启动 Server 和 Client，在浏览器输入 http://localhost:8001/ 可以看到 Client 已经注册到 Server

中英对照：

  • 服务注册中心：Register Service
  • 服务提供者：Provider Service
  • 服务消费者：Consumer Service

完整代码：GitHub

本人 C# 转 Java 的 newbie, 如有错误或不足欢迎指正，谢谢

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家